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

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

Linux/Unix编程

开发平台：

Unix_Linux

sis_main.c：源码内容
  1. /*
  2.  * SiS 300/630/730/540/315/550/650/740 frame buffer device
  3.  * for Linux kernels 2.4.x and 2.5.x
  4.  *
  5.  * Partly based on the VBE 2.0 compliant graphic boards framebuffer driver,
  6.  * which is (c) 1998 Gerd Knorr <kraxel@goldbach.in-berlin.de>
  7.  *
  8.  * Authors:    SiS (www.sis.com.tw)
  9.  * (Various others)
  10.  * Thomas Winischhofer <thomas@winischhofer.net>:
  11.  * - many fixes and enhancements for all chipset series,
  12.  * - extended bridge handling, TV output for Chrontel 7005
  13.  *                      - 650/LVDS support (for LCD panels up to 1400x1050)
  14.  *                      - 650/Chrontel 7019 support
  15.  *                      - 301B/301LV(x)/302B/302LV(x) LCD and TV support
  16.  * - memory queue handling enhancements,
  17.  *                      - 2D acceleration and y-panning,
  18.  *                      - portation to 2.5 API (yet incomplete)
  19.  * - everything marked with "TW" and more
  20.  * (see http://www.winischhofer.net/
  21.  * for more information and updates)
  22.  */
  24. #include <linux/config.h>
  25. #include <linux/version.h>
  26. #include <linux/module.h>
  27. #include <linux/kernel.h>
  28. #include <linux/errno.h>
  29. #include <linux/string.h>
  30. #include <linux/mm.h>
  31. #include <linux/tty.h>
  32. #include <linux/slab.h>
  33. #include <linux/delay.h>
  34. #include <linux/fb.h>
  35. #include <linux/console.h>
  36. #include <linux/selection.h>
  37. #include <linux/ioport.h>
  38. #include <linux/init.h>
  39. #include <linux/pci.h>
  40. #include <linux/vt_kern.h>
  41. #include <linux/capability.h>
  42. #include <linux/fs.h>
  43. #include <linux/agp_backend.h>
  44. #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,33)
  45. #include <linux/spinlock.h>
  46. #endif
  48. #include "osdef.h"
  50. #include <linux/types.h>
  51. #include <linux/sisfb.h>
  53. #include <asm/io.h>
  54. #include <asm/mtrr.h>
  56. #include <video/fbcon.h>
  57. #include <video/fbcon-cfb8.h>
  58. #include <video/fbcon-cfb16.h>
  59. #include <video/fbcon-cfb24.h>
  60. #include <video/fbcon-cfb32.h>
  62. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,34)
  63. #include "../fbcon-accel.h"
  64. #endif
  66. #include "vgatypes.h"
  67. #include "sis_main.h"
  68. #include "sis.h"
  69. //#ifdef LINUXBIOS
  70. //#include "bios.h"
  71. //#endif
  73. /* -------------------- Macro definitions ---------------------------- */
  74. #undef SISFBDEBUG /* TW: no debugging */
  76. #ifdef SISFBDEBUG
  77. #define DPRINTK(fmt, args...) printk(KERN_DEBUG "%s: " fmt, __FUNCTION__ , ## args)
  78. #else
  79. #define DPRINTK(fmt, args...)
  80. #endif
  82. #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,5,33)
  83. #ifdef SISFBACCEL
  84. #ifdef FBCON_HAS_CFB8
  85. extern struct display_switch fbcon_sis8;
  86. #endif
  87. #ifdef FBCON_HAS_CFB16
  88. extern struct display_switch fbcon_sis16;
  89. #endif
  90. #ifdef FBCON_HAS_CFB32
  91. extern struct display_switch fbcon_sis32;
  92. #endif
  93. #endif
  94. #endif
  96. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,34)
  97. /* TEMP */
  98. void my_cfb_imageblit(struct fb_info *info, struct fb_image *image);
  99. #endif
  101. /* --------------- Hardware Access Routines -------------------------- */
  103. void sisfb_set_reg4(u16 port, unsigned long data)
  104. {
  105. outl((u32) (data & 0xffffffff), port);
  106. }
  108. u32 sisfb_get_reg3(u16 port)
  109. {
  110. u32 data;
  112. data = inl(port);
  113. return (data);
  114. }
  116. /* -------------------- Interface to BIOS code -------------------- */
  118. BOOLEAN
  119. sisfb_query_VGA_config_space(PSIS_HW_DEVICE_INFO psishw_ext,
  120. unsigned long offset, unsigned long set, unsigned long *value)
  121. {
  122. static struct pci_dev *pdev = NULL;
  123. static unsigned char init = 0, valid_pdev = 0;
  125. if (!set)
  126. DPRINTK("sisfb: Get VGA offset 0x%lxn", offset);
  127. else
  128. DPRINTK("sisfb: Set offset 0x%lx to 0x%lxn", offset, *value);
  130. if (!init) {
  131. init = TRUE;
  132. pci_for_each_dev(pdev) {
  133. DPRINTK("sisfb: Current: 0x%x, target: 0x%xn",
  134.          pdev->device, ivideo.chip_id);
  135. if ((pdev->vendor == PCI_VENDOR_ID_SI)
  136.            && (pdev->device == ivideo.chip_id)) {
  137. valid_pdev = TRUE;
  138. break;
  139. }
  140. }
  141. }
  143. if (!valid_pdev) {
  144. printk(KERN_DEBUG "sisfb: Can't find SiS %d VGA device.n",
  145. ivideo.chip_id);
  146. return FALSE;
  147. }
  149. if (set == 0)
  150. pci_read_config_dword(pdev, offset, (u32 *)value);
  151. else
  152. pci_write_config_dword(pdev, offset, (u32)(*value));
  154. return TRUE;
  155. }
  157. BOOLEAN sisfb_query_north_bridge_space(PSIS_HW_DEVICE_INFO psishw_ext,
  158. unsigned long offset, unsigned long set, unsigned long *value)
  159. {
  160. static struct pci_dev *pdev = NULL;
  161. static unsigned char init = 0, valid_pdev = 0;
  162. u16 nbridge_id = 0;
  164. if (!init) {
  165. init = TRUE;
  166. switch (ivideo.chip) {
  167. case SIS_540:
  168. nbridge_id = PCI_DEVICE_ID_SI_540;
  169. break;
  170. case SIS_630:
  171. nbridge_id = PCI_DEVICE_ID_SI_630;
  172. break;
  173. case SIS_730:
  174. nbridge_id = PCI_DEVICE_ID_SI_730;
  175. break;
  176. case SIS_550:
  177. nbridge_id = PCI_DEVICE_ID_SI_550;
  178. break;
  179. case SIS_650:
  180. nbridge_id = PCI_DEVICE_ID_SI_650;
  181. break;
  182. default:
  183. nbridge_id = 0;
  184. break;
  185. }
  187. pci_for_each_dev(pdev) {
  188. DPRINTK("Current: 0x%x, target: 0x%xn",
  189. pdev->device, ivideo.chip_id);
  190. if ((pdev->vendor == PCI_VENDOR_ID_SI)
  191. && (pdev->device == nbridge_id)) {
  192. valid_pdev = TRUE;
  193. break;
  194. }
  195. }
  196. }
  198. if (!valid_pdev) {
  199. printk(KERN_DEBUG "sisfb: Can't find SiS %d North Bridge device.n",
  200. nbridge_id);
  201. return FALSE;
  202. }
  204. if (set == 0)
  205. pci_read_config_dword(pdev, offset, (u32 *)value);
  206. else
  207. pci_write_config_dword(pdev, offset, (u32)(*value));
  209. return TRUE;
  210. }
  212. /* -------------------- Exported functions ----------------------------- */
  214. static void sis_get_glyph(struct fb_info *info, SIS_GLYINFO *gly)
  215. {
  216. #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,23)
  217. #define currcon info->currcon
  218. #endif
  219. struct display *p = &fb_display[currcon];
  220. u16 c;
  221. u8 *cdat;
  222. int widthb;
  223. u8 *gbuf = gly->gmask;
  224. int size;
  226. TWDEBUG("Inside get_glyph");
  227. gly->fontheight = fontheight(p);
  228. gly->fontwidth = fontwidth(p);
  229. widthb = (fontwidth(p) + 7) / 8;
  231. c = gly->ch & p->charmask;
  232. if (fontwidth(p) <= 8)
  233. cdat = p->fontdata + c * fontheight(p);
  234. else
  235. cdat = p->fontdata + (c * fontheight(p) << 1);
  237. size = fontheight(p) * widthb;
  238. memcpy(gbuf, cdat, size);
  239. gly->ngmask = size;
  240. TWDEBUG("End of get_glyph");
  241. #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,23)
  242. #undef currcon 
  243. #endif
  244. }
  246. void sis_dispinfo(struct ap_data *rec)
  247. {
  248.         TWDEBUG("Inside dispinfo");
  249. rec->minfo.bpp    = ivideo.video_bpp;
  250. rec->minfo.xres   = ivideo.video_width;
  251. rec->minfo.yres   = ivideo.video_height;
  252. rec->minfo.v_xres = ivideo.video_vwidth;
  253. rec->minfo.v_yres = ivideo.video_vheight;
  254. rec->minfo.org_x  = ivideo.org_x;
  255. rec->minfo.org_y  = ivideo.org_y;
  256. rec->minfo.vrate  = ivideo.refresh_rate;
  257. rec->iobase       = ivideo.vga_base - 0x30;
  258. rec->mem_size     = ivideo.video_size;
  259. rec->disp_state   = ivideo.disp_state; 
  260. rec->version      = (VER_MAJOR << 24) | (VER_MINOR << 16) | VER_LEVEL; 
  261. rec->hasVB        = ivideo.hasVB; 
  262. rec->TV_type      = ivideo.TV_type; 
  263. rec->TV_plug      = ivideo.TV_plug; 
  264. rec->chip         = ivideo.chip;
  265. TWDEBUG("End of dispinfo");
  266. }
  268. /* ------------------ Internal Routines ------------------------------ */
  270. static void sisfb_search_mode(const char *name)
  271. {
  272. int i = 0, j = 0;
  274. if(name == NULL)
  275. return;
  277. while(sisbios_mode[i].mode_no != 0) {
  278. if (!strcmp(name, sisbios_mode[i].name)) {
  279. sisfb_mode_idx = i;
  280. j = 1;
  281. break;
  282. }
  283. i++;
  284. }
  285. if(!j) printk(KERN_INFO "sisfb: Invalid mode '%s'n", name);
  286. }
  288. static void sisfb_search_vesamode(unsigned int vesamode)
  289. {
  290. int i = 0, j = 0;
  292. if(vesamode == 0) {
  293. sisfb_mode_idx = MODE_INDEX_NONE;
  294. return;
  295. }
  297. vesamode &= 0x1dff;  /* Clean VESA mode number from other flags */
  299. while(sisbios_mode[i].mode_no != 0) {
  300. if( (sisbios_mode[i].vesa_mode_no_1 == vesamode) ||
  301.     (sisbios_mode[i].vesa_mode_no_2 == vesamode) ) {
  302. sisfb_mode_idx = i;
  303. j = 1;
  304. break;
  305. }
  306. i++;
  307. }
  308. if(!j) printk(KERN_INFO "sisfb: Invalid VESA mode 0x%x'n", vesamode);
  309. }
  311. static int sisfb_validate_mode(int myindex)
  312. {
  313.    u16 xres, yres;
  315. #ifdef CONFIG_FB_SIS_300
  316.    if(sisvga_engine == SIS_300_VGA) {
  317.        if(!(sisbios_mode[sisfb_mode_idx].chipset & MD_SIS300)) {
  318.            return(-1);
  319.        }
  320.    }
  321. #endif
  322. #ifdef CONFIG_FB_SIS_315
  323.    if(sisvga_engine == SIS_315_VGA) {
  324.        if(!(sisbios_mode[myindex].chipset & MD_SIS315)) {
  325.    return(-1);
  326.        }
  327.    }
  328. #endif
  330.    switch (ivideo.disp_state & DISPTYPE_DISP2) {
  331.      case DISPTYPE_LCD:
  332. switch (sishw_ext.ulCRT2LCDType) {
  333. case LCD_1024x768:
  334.   xres = 1024; yres =  768;  break;
  335. case LCD_1280x1024:
  336. xres = 1280; yres = 1024;  break;
  337. case LCD_1280x960:
  338.         xres = 1280; yres =  960;  break;
  339. case LCD_2048x1536:
  340. xres = 2048; yres = 1536;  break;
  341. case LCD_1920x1440:
  342. xres = 1920; yres = 1440;  break;
  343. case LCD_1600x1200:
  344. xres = 1600; yres = 1200;  break;
  345. case LCD_800x600:
  346. xres =  800; yres =  600;  break;
  347. case LCD_640x480:
  348. xres =  640; yres =  480;  break;
  349. case LCD_320x480: /* TW: FSTN */
  350. xres =  320; yres =  480;  break;
  351.         case LCD_1024x600:
  352. xres = 1024; yres =  600;  break;
  353. case LCD_1152x864:
  354. xres = 1152; yres =  864;  break;
  355. case LCD_1152x768:
  356. xres = 1152; yres =  768;  break;
  357. case LCD_1280x768:
  358. xres = 1280; yres =  768;  break;
  359. case LCD_1400x1050:
  360. xres = 1400; yres = 1050;  break;
  361. default:
  362.         xres =    0; yres =    0;  break;
  363. }
  364. if(sisbios_mode[myindex].xres > xres) {
  365.         return(-1);
  366. }
  367.         if(sisbios_mode[myindex].yres > yres) {
  368.         return(-1);
  369. }
  370. if (sisbios_mode[myindex].xres == 720) {
  371. return(-1);
  372. }
  373. break;
  374.      case DISPTYPE_TV:
  375. switch (sisbios_mode[myindex].xres) {
  376. case 512:
  377. case 640:
  378. case 800:
  379. break;
  380. case 720:
  381. if (ivideo.TV_type == TVMODE_NTSC) {
  382. if (sisbios_mode[myindex].yres != 480) {
  383. return(-1);
  384. }
  385. } else if (ivideo.TV_type == TVMODE_PAL) {
  386. if (sisbios_mode[myindex].yres != 576) {
  387. return(-1);
  388. }
  389. }
  390. /* TW: LVDS/CHRONTEL does not support 720 */
  391. if (ivideo.hasVB == HASVB_LVDS_CHRONTEL ||
  392. ivideo.hasVB == HASVB_CHRONTEL) {
  393. return(-1);
  394. }
  395. break;
  396. case 1024:
  397. if (ivideo.TV_type == TVMODE_NTSC) {
  398. if(sisbios_mode[myindex].bpp == 32) {
  399.        return(-1);
  400. }
  401. }
  402. /* TW: LVDS/CHRONTEL only supports < 800 (1024 on 650/Ch7019)*/
  403. if (ivideo.hasVB == HASVB_LVDS_CHRONTEL ||
  404. ivideo.hasVB == HASVB_CHRONTEL) {
  405.     if(ivideo.chip < SIS_315H) {
  406. return(-1);
  407.     }
  408. }
  409. break;
  410. default:
  411. return(-1);
  412. }
  413. break;
  414.      }
  415.      return(myindex);
  416. }
  418. static void sisfb_search_crt2type(const char *name)
  419. {
  420. int i = 0;
  422. if(name == NULL)
  423. return;
  425. while(sis_crt2type[i].type_no != -1) {
  426. if (!strcmp(name, sis_crt2type[i].name)) {
  427. sisfb_crt2type = sis_crt2type[i].type_no;
  428. sisfb_tvplug = sis_crt2type[i].tvplug_no;
  429. break;
  430. }
  431. i++;
  432. }
  433. if(sisfb_crt2type < 0)
  434. printk(KERN_INFO "sisfb: Invalid CRT2 type: %sn", name);
  435. }
  437. static void sisfb_search_queuemode(const char *name)
  438. {
  439. int i = 0;
  441. if(name == NULL)
  442. return;
  444. while (sis_queuemode[i].type_no != -1) {
  445. if (!strcmp(name, sis_queuemode[i].name)) {
  446. sisfb_queuemode = sis_queuemode[i].type_no;
  447. break;
  448. }
  449. i++;
  450. }
  451. if (sisfb_queuemode < 0)
  452. printk(KERN_INFO "sisfb: Invalid queuemode type: %sn", name);
  453. }
  455. static u8 sisfb_search_refresh_rate(unsigned int rate)
  456. {
  457. u16 xres, yres;
  458. int i = 0;
  460. xres = sisbios_mode[sisfb_mode_idx].xres;
  461. yres = sisbios_mode[sisfb_mode_idx].yres;
  463. sisfb_rate_idx = 0;
  464. while ((sisfb_vrate[i].idx != 0) && (sisfb_vrate[i].xres <= xres)) {
  465. if ((sisfb_vrate[i].xres == xres) && (sisfb_vrate[i].yres == yres)) {
  466. if (sisfb_vrate[i].refresh == rate) {
  467. sisfb_rate_idx = sisfb_vrate[i].idx;
  468. break;
  469. } else if (sisfb_vrate[i].refresh > rate) {
  470. if ((sisfb_vrate[i].refresh - rate) <= 2) {
  471. DPRINTK("sisfb: Adjusting rate from %d up to %dn",
  472. rate, sisfb_vrate[i].refresh);
  473. sisfb_rate_idx = sisfb_vrate[i].idx;
  474. ivideo.refresh_rate = sisfb_vrate[i].refresh;
  475. } else if (((rate - sisfb_vrate[i-1].refresh) <= 2)
  476. && (sisfb_vrate[i].idx != 1)) {
  477. DPRINTK("sisfb: Adjusting rate from %d down to %dn",
  478. rate, sisfb_vrate[i-1].refresh);
  479. sisfb_rate_idx = sisfb_vrate[i-1].idx;
  480. ivideo.refresh_rate = sisfb_vrate[i-1].refresh;
  481. }
  482. break;
  483. }
  484. }
  485. i++;
  486. }
  487. if (sisfb_rate_idx > 0) {
  488. return sisfb_rate_idx;
  489. } else {
  490. printk(KERN_INFO
  491. "sisfb: Unsupported rate %d for %dx%dn", rate, xres, yres);
  492. return 0;
  493. }
  494. }
  496. #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,5,33)
  497. static int sis_getcolreg(unsigned regno, unsigned *red, unsigned *green, unsigned *blue,
  498.  unsigned *transp, struct fb_info *fb_info)
  499. {
  500. if (regno >= ivideo.video_cmap_len)
  501. return 1;
  503. *red = sis_palette[regno].red;
  504. *green = sis_palette[regno].green;
  505. *blue = sis_palette[regno].blue;
  506. *transp = 0;
  507. return 0;
  508. }
  509. #endif
  511. static int sisfb_setcolreg(unsigned regno, unsigned red, unsigned green, unsigned blue,
  512.                            unsigned transp, struct fb_info *fb_info)
  513. {
  514. if (regno >= ivideo.video_cmap_len)
  515. return 1;
  517. sis_palette[regno].red = red;
  518. sis_palette[regno].green = green;
  519. sis_palette[regno].blue = blue;
  521. switch (ivideo.video_bpp) {
  522. #ifdef FBCON_HAS_CFB8
  523. case 8:
  524.         outSISREG(SISDACA, regno);
  525. outSISREG(SISDACD, (red >> 10));
  526. outSISREG(SISDACD, (green >> 10));
  527. outSISREG(SISDACD, (blue >> 10));
  528. if (ivideo.disp_state & DISPTYPE_DISP2) {
  529.         outSISREG(SISDAC2A, regno);
  530. outSISREG(SISDAC2D, (red >> 8));
  531. outSISREG(SISDAC2D, (green >> 8));
  532. outSISREG(SISDAC2D, (blue >> 8));
  533. }
  534. break;
  535. #endif
  536. #ifdef FBCON_HAS_CFB16
  537. case 15:
  538. case 16:
  539. sis_fbcon_cmap.cfb16[regno] =
  540.     ((red & 0xf800)) | ((green & 0xfc00) >> 5) | ((blue & 0xf800) >> 11);
  541. break;
  542. #endif
  543. #ifdef FBCON_HAS_CFB24
  544. case 24:
  545. red >>= 8;
  546. green >>= 8;
  547. blue >>= 8;
  548. sis_fbcon_cmap.cfb24[regno] = (red << 16) | (green << 8) | (blue);
  549. break;
  550. #endif
  551. #ifdef FBCON_HAS_CFB32
  552. case 32:
  553. red >>= 8;
  554. green >>= 8;
  555. blue >>= 8;
  556. sis_fbcon_cmap.cfb32[regno] = (red << 16) | (green << 8) | (blue);
  557. break;
  558. #endif
  559. }
  560. return 0;
  561. }
  563. static int sisfb_do_set_var(struct fb_var_screeninfo *var, int isactive,
  564.       struct fb_info *info)
  565. {
  566. unsigned int htotal =
  567. var->left_margin + var->xres + var->right_margin +
  568. var->hsync_len;
  569. unsigned int vtotal = 0; /* TW */
  570. /* var->upper_margin + var->yres + var->lower_margin +
  571. var->vsync_len;     */
  572. double drate = 0, hrate = 0;
  573. int found_mode = 0;
  574. int old_mode;
  576. TWDEBUG("Inside do_set_var");
  578. if((var->vmode & FB_VMODE_MASK) == FB_VMODE_NONINTERLACED) {
  579. vtotal = var->upper_margin + var->yres + var->lower_margin +
  580.          var->vsync_len;   /* TW */
  581. vtotal <<= 1;
  582. } else if((var->vmode & FB_VMODE_MASK) == FB_VMODE_DOUBLE) {
  583. vtotal = var->upper_margin + var->yres + var->lower_margin +
  584.          var->vsync_len;   /* TW */
  585. vtotal <<= 2;
  586. } else if((var->vmode & FB_VMODE_MASK) == FB_VMODE_INTERLACED) {
  587. vtotal = var->upper_margin + (var->yres/2) + var->lower_margin +
  588.          var->vsync_len;   /* TW */
  589. /* var->yres <<= 1; */ /* TW */
  590. } else  vtotal = var->upper_margin + var->yres + var->lower_margin +
  591.          var->vsync_len;
  593. if(!(htotal) || !(vtotal)) {
  594. DPRINTK("sisfb: Invalid 'var' informationn");
  595. return -EINVAL;
  596. }
  598. drate = 1E12 / var->pixclock;
  599. hrate = drate / htotal;
  600. ivideo.refresh_rate = (unsigned int) (hrate / vtotal * 2 + 0.5);
  602. /* TW: Calculation wrong for 1024x600 - force it to 60Hz */
  603. if((var->xres == 1024) && (var->yres == 600)) ivideo.refresh_rate = 60;
  605. printk("sisfb: Change mode to %dx%dx%d-%dHzn",
  606. var->xres,var->yres,var->bits_per_pixel,ivideo.refresh_rate);
  608. old_mode = sisfb_mode_idx;
  609. sisfb_mode_idx = 0;
  611. while( (sisbios_mode[sisfb_mode_idx].mode_no != 0) &&
  612.        (sisbios_mode[sisfb_mode_idx].xres <= var->xres) ) {
  613. if( (sisbios_mode[sisfb_mode_idx].xres == var->xres) &&
  614.     (sisbios_mode[sisfb_mode_idx].yres == var->yres) &&
  615.     (sisbios_mode[sisfb_mode_idx].bpp == var->bits_per_pixel)) {
  616. sisfb_mode_no = sisbios_mode[sisfb_mode_idx].mode_no;
  617. found_mode = 1;
  618. break;
  619. }
  620. sisfb_mode_idx++;
  621. }
  623. if(found_mode)
  624. sisfb_mode_idx = sisfb_validate_mode(sisfb_mode_idx);
  625. else
  626. sisfb_mode_idx = -1;
  628.         if(sisfb_mode_idx < 0) {
  629. printk("sisfb: Mode %dx%dx%d not supportedn", var->xres,
  630.        var->yres, var->bits_per_pixel);
  631. sisfb_mode_idx = old_mode;
  632. return -EINVAL;
  633. }
  635. if(sisfb_search_refresh_rate(ivideo.refresh_rate) == 0) {
  636. sisfb_rate_idx = sisbios_mode[sisfb_mode_idx].rate_idx;
  637. ivideo.refresh_rate = 60;
  638. }
  640. #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,5,33)
  641. if(((var->activate & FB_ACTIVATE_MASK) == FB_ACTIVATE_NOW) && isactive) {
  642. #else
  643. if(isactive) {
  644. #endif
  645. sisfb_pre_setmode();
  647. if(SiSSetMode(&SiS_Pr, &sishw_ext, sisfb_mode_no) == 0) {
  648. printk("sisfb: Setting mode[0x%x] failedn", sisfb_mode_no);
  649. return -EINVAL;
  650. }
  652. outSISIDXREG(SISSR, IND_SIS_PASSWORD, SIS_PASSWORD);
  654. sisfb_post_setmode();
  656. DPRINTK("sisfb: Set new mode: %dx%dx%d-%d n",
  657. sisbios_mode[sisfb_mode_idx].xres,
  658. sisbios_mode[sisfb_mode_idx].yres,
  659. sisbios_mode[sisfb_mode_idx].bpp,
  660. ivideo.refresh_rate);
  662. ivideo.video_bpp = sisbios_mode[sisfb_mode_idx].bpp;
  663. ivideo.video_vwidth = ivideo.video_width = sisbios_mode[sisfb_mode_idx].xres;
  664. ivideo.video_vheight = ivideo.video_height = sisbios_mode[sisfb_mode_idx].yres;
  665. ivideo.org_x = ivideo.org_y = 0;
  666. ivideo.video_linelength = ivideo.video_width * (ivideo.video_bpp >> 3);
  667. switch(ivideo.video_bpp) {
  668.          case 8:
  669.              ivideo.DstColor = 0x0000;
  670.      ivideo.SiS310_AccelDepth = 0x00000000;
  671. ivideo.video_cmap_len = 256;
  672.              break;
  673.          case 16:
  674.              ivideo.DstColor = 0x8000;
  675.              ivideo.SiS310_AccelDepth = 0x00010000;
  676. ivideo.video_cmap_len = 16;
  677.              break;
  678.          case 32:
  679.              ivideo.DstColor = 0xC000;
  680.      ivideo.SiS310_AccelDepth = 0x00020000;
  681. ivideo.video_cmap_len = 16;
  682.              break;
  683. default:
  684. ivideo.video_cmap_len = 16;
  685.         printk(KERN_ERR "sisfb: Unsupported accel depth %d", ivideo.video_bpp);
  686. break;
  687.      }
  688. }
  689. TWDEBUG("End of do_set_var");
  690. return 0;
  691. }
  693. /* ------ Internal functions only for 2.4 series ------- */
  695. #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,5,33)
  696. static void sisfb_set_disp(int con, struct fb_var_screeninfo *var,
  697.                            struct fb_info *info)
  698. {
  699. struct fb_fix_screeninfo fix;
  700. long   flags;
  701. struct display *display;
  702. struct display_switch *sw;
  704. if(con >= 0)
  705. display = &fb_display[con];
  706. else
  707. display = &sis_disp;
  709. sisfb_get_fix(&fix, con, 0);
  711. #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,5,23)
  712. display->screen_base = ivideo.video_vbase;
  713. #endif
  714. display->visual = fix.visual;
  715. display->type = fix.type;
  716. display->type_aux = fix.type_aux;
  717. display->ypanstep = fix.ypanstep;
  718. display->ywrapstep = fix.ywrapstep;
  719. display->line_length = fix.line_length;
  720. display->next_line = fix.line_length;
  721. display->can_soft_blank = 0;
  722. display->inverse = sisfb_inverse;
  723. display->var = *var;
  725. save_flags(flags);
  727. switch (ivideo.video_bpp) {
  728. #ifdef FBCON_HAS_CFB8
  729.    case 8:
  730. #ifdef SISFBACCEL
  731. sw = sisfb_accel ? &fbcon_sis8 : &fbcon_cfb8;
  732. #else
  733. sw = &fbcon_cfb8;
  734. #endif
  735. break;
  736. #endif
  737. #ifdef FBCON_HAS_CFB16
  738.    case 15:
  739.    case 16:
  740. #ifdef SISFBACCEL
  741. sw = sisfb_accel ? &fbcon_sis16 : &fbcon_cfb16;
  742. #else
  743. sw = &fbcon_cfb16;
  744. #endif
  745. display->dispsw_data = sis_fbcon_cmap.cfb16;
  746. break;
  747. #endif
  748. #ifdef FBCON_HAS_CFB24
  749.    case 24:
  750. sw = &fbcon_cfb24;
  751. display->dispsw_data = sis_fbcon_cmap.cfb24;
  752. break;
  753. #endif
  754. #ifdef FBCON_HAS_CFB32
  755.    case 32:
  756. #ifdef SISFBACCEL
  757. sw = sisfb_accel ? &fbcon_sis32 : &fbcon_cfb32;
  758. #else
  759. sw = &fbcon_cfb32;
  760. #endif
  761. display->dispsw_data = sis_fbcon_cmap.cfb32;
  762. break;
  763. #endif
  764.    default:
  765. sw = &fbcon_dummy;
  766. return;
  767. }
  768. memcpy(&sisfb_sw, sw, sizeof(*sw));
  769. display->dispsw = &sisfb_sw;
  770. restore_flags(flags);
  772. #ifdef SISFB_PAN
  773.         if(sisfb_ypan) {
  774.        /* display->scrollmode = SCROLL_YPAN; - not defined */
  775. } else {
  776.     display->scrollmode = SCROLL_YREDRAW;
  777.     sisfb_sw.bmove = fbcon_redraw_bmove;
  778. }
  779. #else
  780. display->scrollmode = SCROLL_YREDRAW;
  781. sisfb_sw.bmove = fbcon_redraw_bmove;
  782. #endif
  783. }
  785. static void sisfb_do_install_cmap(int con, struct fb_info *info)
  786. {
  787. #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,23)
  788. if (con != info->currcon)
  789. return;
  791.         if (fb_display[con].cmap.len)
  792.                 fb_set_cmap(&fb_display[con].cmap, 1, info);
  793.         else
  794. fb_set_cmap(fb_default_cmap(ivideo.video_cmap_len), 1, info);
  795. #else
  796.         if (con != currcon)
  797. return;
  799.         if (fb_display[con].cmap.len)
  800. fb_set_cmap(&fb_display[con].cmap, 1, sisfb_setcolreg, info);
  801.         else
  802. fb_set_cmap(fb_default_cmap(ivideo.video_cmap_len), 1,
  803.     sisfb_setcolreg, info);
  804. #endif
  805. }
  806. #endif
  808. /* ------ functions for all series ------ */
  810. #ifdef SISFB_PAN
  811. static void sisfb_pan_var(struct fb_var_screeninfo *var)
  812. {
  813. unsigned int base;
  815. TWDEBUG("Inside pan_var");
  817.         base = var->yoffset * var->xres_virtual + var->xoffset;
  819.         /* calculate base bpp dep. */
  820.         switch(var->bits_per_pixel) {
  821.         case 16:
  822.          base >>= 1;
  823.          break;
  824. case 32:
  825.              break;
  826. case 8:
  827.         default:
  828.          base >>= 2;
  829.              break;
  830.         }
  832. outSISIDXREG(SISSR, IND_SIS_PASSWORD, SIS_PASSWORD);
  834.         outSISIDXREG(SISCR, 0x0D, base & 0xFF);
  835. outSISIDXREG(SISCR, 0x0C, (base >> 8) & 0xFF);
  836. outSISIDXREG(SISSR, 0x0D, (base >> 16) & 0xFF);
  837. if(sisvga_engine == SIS_315_VGA) {
  838. setSISIDXREG(SISSR, 0x37, 0xFE, (base >> 24) & 0x01);
  839. }
  840.         if(ivideo.disp_state & DISPTYPE_DISP2) {
  841. orSISIDXREG(SISPART1, sisfb_CRT2_write_enable, 0x01);
  842.          outSISIDXREG(SISPART1, 0x06, (base & 0xFF));
  843.          outSISIDXREG(SISPART1, 0x05, ((base >> 8) & 0xFF));
  844.          outSISIDXREG(SISPART1, 0x04, ((base >> 16) & 0xFF));
  845. if(sisvga_engine == SIS_315_VGA) {
  846. setSISIDXREG(SISPART1, 0x02, 0x7F, ((base >> 24) & 0x01) << 7);
  847. }
  848.         }
  849. TWDEBUG("End of pan_var");
  850. }
  851. #endif
  853. static void sisfb_crtc_to_var(struct fb_var_screeninfo *var)
  854. {
  855. u16 VRE, VBE, VRS, VBS, VDE, VT;
  856. u16 HRE, HBE, HRS, HBS, HDE, HT;
  857. u8  sr_data, cr_data, cr_data2, cr_data3, mr_data;
  858. int A, B, C, D, E, F, temp;
  859. double hrate, drate;
  861. TWDEBUG("Inside crtc_to_var");
  862. inSISIDXREG(SISSR, IND_SIS_COLOR_MODE, sr_data);
  864. if (sr_data & SIS_INTERLACED_MODE)
  865. var->vmode = FB_VMODE_INTERLACED;
  866. else
  867. var->vmode = FB_VMODE_NONINTERLACED;
  869. switch ((sr_data & 0x1C) >> 2) {
  870.    case SIS_8BPP_COLOR_MODE:
  871. var->bits_per_pixel = 8;
  872. break;
  873.    case SIS_16BPP_COLOR_MODE:
  874. var->bits_per_pixel = 16;
  875. break;
  876.    case SIS_32BPP_COLOR_MODE:
  877. var->bits_per_pixel = 32;
  878. break;
  879. }
  881. switch (var->bits_per_pixel) {
  882.    case 8:
  883. var->red.length = 6;
  884. var->green.length = 6;
  885. var->blue.length = 6;
  886. ivideo.video_cmap_len = 256;
  887. break;
  888.    case 16:
  889. var->red.offset = 11;
  890. var->red.length = 5;
  891. var->green.offset = 5;
  892. var->green.length = 6;
  893. var->blue.offset = 0;
  894. var->blue.length = 5;
  895. var->transp.offset = 0;
  896. var->transp.length = 0;
  897. ivideo.video_cmap_len = 16;
  898. break;
  899.    case 24:
  900. var->red.offset = 16;
  901. var->red.length = 8;
  902. var->green.offset = 8;
  903. var->green.length = 8;
  904. var->blue.offset = 0;
  905. var->blue.length = 8;
  906. var->transp.offset = 0;
  907. var->transp.length = 0;
  908. ivideo.video_cmap_len = 16;
  909. break;
  910.    case 32:
  911. var->red.offset = 16;
  912. var->red.length = 8;
  913. var->green.offset = 8;
  914. var->green.length = 8;
  915. var->blue.offset = 0;
  916. var->blue.length = 8;
  917. var->transp.offset = 24;
  918. var->transp.length = 8;
  919. ivideo.video_cmap_len = 16;
  920. break;
  921. }
  923. inSISIDXREG(SISSR, 0x0A, sr_data);
  925.         inSISIDXREG(SISCR, 0x06, cr_data);
  927.         inSISIDXREG(SISCR, 0x07, cr_data2);
  929. VT = (cr_data & 0xFF) | ((u16) (cr_data2 & 0x01) << 8) |
  930.      ((u16) (cr_data2 & 0x20) << 4) | ((u16) (sr_data & 0x01) << 10);
  931. A = VT + 2;
  933. inSISIDXREG(SISCR, 0x12, cr_data);
  935. VDE = (cr_data & 0xff) | ((u16) (cr_data2 & 0x02) << 7) |
  936.       ((u16) (cr_data2 & 0x40) << 3) | ((u16) (sr_data & 0x02) << 9);
  937. E = VDE + 1;
  939. inSISIDXREG(SISCR, 0x10, cr_data);
  941. VRS = (cr_data & 0xff) | ((u16) (cr_data2 & 0x04) << 6) |
  942.       ((u16) (cr_data2 & 0x80) << 2) | ((u16) (sr_data & 0x08) << 7);
  943. F = VRS + 1 - E;
  945. inSISIDXREG(SISCR, 0x15, cr_data);
  947. inSISIDXREG(SISCR, 0x09, cr_data3);
  949. VBS = (cr_data & 0xff) | ((u16) (cr_data2 & 0x08) << 5) |
  950.       ((u16) (cr_data3 & 0x20) << 4) | ((u16) (sr_data & 0x04) << 8);
  952. inSISIDXREG(SISCR, 0x16, cr_data);
  954. VBE = (cr_data & 0xff) | ((u16) (sr_data & 0x10) << 4);
  955. temp = VBE - ((E - 1) & 511);
  956. B = (temp > 0) ? temp : (temp + 512);
  958. inSISIDXREG(SISCR, 0x11, cr_data);
  960. VRE = (cr_data & 0x0f) | ((sr_data & 0x20) >> 1);
  961. temp = VRE - ((E + F - 1) & 31);
  962. C = (temp > 0) ? temp : (temp + 32);
  964. D = B - F - C;
  967.         var->yres = E;
  968. #ifndef SISFB_PAN
  969. var->yres_virtual = E;
  970. #endif
  971. /* TW: We have to report the physical dimension to the console! */
  972. if ((var->vmode & FB_VMODE_MASK) == FB_VMODE_INTERLACED) {
  973. var->yres <<= 1;
  974. #ifndef SISFB_PAN
  975. var->yres_virtual <<= 1;
  976. #endif
  977. }
  978. /* TW end */
  979. var->upper_margin = D;
  980. var->lower_margin = F;
  981. var->vsync_len = C;
  983. inSISIDXREG(SISSR, 0x0b, sr_data);
  985. inSISIDXREG(SISCR, 0x00, cr_data);
  987. HT = (cr_data & 0xff) | ((u16) (sr_data & 0x03) << 8);
  988. A = HT + 5;
  990. inSISIDXREG(SISCR, 0x01, cr_data);
  992. HDE = (cr_data & 0xff) | ((u16) (sr_data & 0x0C) << 6);
  993. E = HDE + 1;
  995. inSISIDXREG(SISCR, 0x04, cr_data);
  997. HRS = (cr_data & 0xff) | ((u16) (sr_data & 0xC0) << 2);
  998. F = HRS - E - 3;
  1000. inSISIDXREG(SISCR, 0x02, cr_data);
  1002. HBS = (cr_data & 0xff) | ((u16) (sr_data & 0x30) << 4);
  1004. inSISIDXREG(SISSR, 0x0c, sr_data);
  1006. inSISIDXREG(SISCR, 0x03, cr_data);
  1008. inSISIDXREG(SISCR, 0x15, cr_data2);
  1010. HBE = (cr_data & 0x1f) | ((u16) (cr_data2 & 0x80) >> 2) |
  1011.       ((u16) (sr_data & 0x03) << 6);
  1012. HRE = (cr_data2 & 0x1f) | ((sr_data & 0x04) << 3);
  1014. temp = HBE - ((E - 1) & 255);
  1015. B = (temp > 0) ? temp : (temp + 256);
  1017. temp = HRE - ((E + F + 3) & 63);
  1018. C = (temp > 0) ? temp : (temp + 64);
  1020. D = B - F - C;
  1022. var->xres = var->xres_virtual = E * 8;
  1023. var->left_margin = D * 8;
  1024. var->right_margin = F * 8;
  1025. var->hsync_len = C * 8;
  1027. var->activate = FB_ACTIVATE_NOW;
  1029. var->sync = 0;
  1031. mr_data = inSISREG(SISMISCR);
  1032. #if 0
  1033. mr_data = vgarb(0x1C);
  1034. #endif
  1035. if (mr_data & 0x80)
  1036. var->sync &= ~FB_SYNC_VERT_HIGH_ACT;
  1037. else
  1038. var->sync |= FB_SYNC_VERT_HIGH_ACT;
  1040. if (mr_data & 0x40)
  1041. var->sync &= ~FB_SYNC_HOR_HIGH_ACT;
  1042. else
  1043. var->sync |= FB_SYNC_HOR_HIGH_ACT;
  1045. VT += 2;
  1046. VT <<= 1;
  1047. HT = (HT + 5) * 8;
  1049. hrate = (double) ivideo.refresh_rate * (double) VT / 2;
  1050. drate = hrate * HT;
  1051. var->pixclock = (u32) (1E12 / drate);
  1053. #ifdef SISFB_PAN
  1054. if(sisfb_ypan) {
  1055.     var->yres_virtual = ivideo.heapstart / (var->xres * (var->bits_per_pixel >> 3));
  1056.     if(var->yres_virtual <= var->yres) {
  1057.         var->yres_virtual = var->yres;
  1058.     }
  1059. } else
  1060. #endif
  1061.    var->yres_virtual = var->yres;
  1063.         TWDEBUG("end of crtc_to_var");
  1064. }
  1066. /* ------------------ Public Routines -------------------------------- */
  1068. /* -------- functions only for for 2.4 series ------- */
  1070. #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,5,33)
  1071. static int sisfb_set_var(struct fb_var_screeninfo *var, int con,
  1072.  struct fb_info *info)
  1073. {
  1074. #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,23)
  1075. #define currcon info->currcon
  1076. #endif
  1077. int err;
  1078. unsigned int cols, rows;
  1080. fb_display[con].var.activate = FB_ACTIVATE_NOW;
  1081.         if(sisfb_do_set_var(var, con == currcon, info)) {
  1082. sisfb_crtc_to_var(var);
  1083. return -EINVAL;
  1084. }
  1086. sisfb_crtc_to_var(var);
  1088. sisfb_set_disp(con, var, info);
  1090. if(info->changevar)
  1091. (*info->changevar) (con);
  1093. if((err = fb_alloc_cmap(&fb_display[con].cmap, 0, 0)))
  1094. return err;
  1096. sisfb_do_install_cmap(con, info);
  1098. cols = sisbios_mode[sisfb_mode_idx].cols;
  1099. rows = sisbios_mode[sisfb_mode_idx].rows;
  1100. vc_resize_con(rows, cols, fb_display[con].conp->vc_num);
  1102. return 0;
  1103. #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,23)
  1104. #undef currcon
  1105. #endif
  1106. }
  1108. static int sisfb_get_cmap(struct fb_cmap *cmap, int kspc, int con,
  1109.   struct fb_info *info)
  1110. {
  1111. #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,23)
  1112. #define currcon info->currcon
  1113. #endif
  1114.         if (con == currcon)
  1115. return fb_get_cmap(cmap, kspc, sis_getcolreg, info);
  1117. else if (fb_display[con].cmap.len)
  1118. fb_copy_cmap(&fb_display[con].cmap, cmap, kspc ? 0 : 2);
  1119. else
  1120. fb_copy_cmap(fb_default_cmap(ivideo.video_cmap_len), cmap, kspc ? 0 : 2);
  1122. return 0;
  1123. #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,23)
  1124. #undef currcon
  1125. #endif
  1126. }
  1128. static int sisfb_set_cmap(struct fb_cmap *cmap, int kspc, int con,
  1129.   struct fb_info *info)
  1130. {
  1131. int err;
  1133. if (!fb_display[con].cmap.len) {
  1134. err = fb_alloc_cmap(&fb_display[con].cmap, ivideo.video_cmap_len, 0);
  1135. if (err)
  1136. return err;
  1137. }
  1138. #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,23)
  1139. if (con == info->currcon)
  1140. return fb_set_cmap(cmap, kspc, info);
  1141. #else
  1142.         if (con == currcon)
  1143. return fb_set_cmap(cmap, kspc, sisfb_setcolreg, info);
  1144. #endif
  1145. else
  1146. fb_copy_cmap(cmap, &fb_display[con].cmap, kspc ? 0 : 1);
  1147. return 0;
  1148. }
  1149. #endif
  1151. /* -------- functions only for 2.5 series ------- */
  1153. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,34)
  1154. static int sisfb_set_par(struct fb_info *info)
  1155. {
  1156. int err;
  1158. TWDEBUG("inside set_parn");
  1159.         if((err = sisfb_do_set_var(&info->var, 1, info)))
  1160. return err;
  1162. sisfb_get_fix(&info->fix, info->currcon, info);
  1164. TWDEBUG("end of set_par");
  1165. return 0;
  1166. }
  1168. static int sisfb_check_var(struct fb_var_screeninfo *var,
  1169.                             struct fb_info *info)
  1170. {
  1171. unsigned int htotal =
  1172. var->left_margin + var->xres + var->right_margin +
  1173. var->hsync_len;
  1174. unsigned int vtotal = 0;
  1175. double drate = 0, hrate = 0;
  1176. int found_mode = 0;
  1177. int refresh_rate, search_idx;
  1179. TWDEBUG("Inside check_var");
  1181. if((var->vmode & FB_VMODE_MASK) == FB_VMODE_NONINTERLACED) {
  1182. vtotal = var->upper_margin + var->yres + var->lower_margin +
  1183.          var->vsync_len;   /* TW */
  1184. vtotal <<= 1;
  1185. } else if((var->vmode & FB_VMODE_MASK) == FB_VMODE_DOUBLE) {
  1186. vtotal = var->upper_margin + var->yres + var->lower_margin +
  1187.          var->vsync_len;   /* TW */
  1188. vtotal <<= 2;
  1189. } else if((var->vmode & FB_VMODE_MASK) == FB_VMODE_INTERLACED) {
  1190. vtotal = var->upper_margin + (var->yres/2) + var->lower_margin +
  1191.          var->vsync_len;   /* TW */
  1192. /* var->yres <<= 1; */ /* TW */
  1193. } else  vtotal = var->upper_margin + var->yres + var->lower_margin +
  1194.          var->vsync_len;
  1196. if(!(htotal) || !(vtotal)) {
  1197. SISFAIL("sisfb: no valid timing data");
  1198. }
  1200. drate = 1E12 / var->pixclock;
  1201. hrate = drate / htotal;
  1202. refresh_rate = (unsigned int) (hrate / vtotal * 2 + 0.5);
  1204. /* TW: Calculation wrong for 1024x600 - force it to 60Hz */
  1205. if((var->xres == 1024) && (var->yres == 600)) refresh_rate = 60;
  1207. search_idx = 0;
  1208. while( (sisbios_mode[search_idx].mode_no != 0) &&
  1209.        (sisbios_mode[search_idx].xres <= var->xres) ) {
  1210. if( (sisbios_mode[search_idx].xres == var->xres) &&
  1211.     (sisbios_mode[search_idx].yres == var->yres) &&
  1212.     (sisbios_mode[search_idx].bpp == var->bits_per_pixel)) {
  1213. found_mode = 1;
  1214. break;
  1215. }
  1216. search_idx++;
  1217. }
  1219. /* TW: TODO: Check the refresh rate */
  1221. if(found_mode)
  1222. search_idx = sisfb_validate_mode(search_idx);
  1223. else
  1224. SISFAIL("sisfb: no valid mode");
  1226.         if(sisfb_mode_idx < 0) {
  1227. SISFAIL("sisfb: mode not supported");
  1228. }
  1230. /* TW: Horiz-panning not supported */
  1231. if(var->xres != var->xres_virtual)
  1232. var->xres_virtual = var->xres;
  1234. if(!sisfb_ypan) {
  1235. if(var->yres != var->yres_virtual)
  1236. var->yres_virtual = var->yres;
  1237. } else {
  1238.    /* TW: Now patch yres_virtual if we use panning */
  1239.    /* *** May I do this? *** */
  1240.    var->yres_virtual = ivideo.heapstart / (var->xres * (var->bits_per_pixel >> 3));
  1241.     if(var->yres_virtual <= var->yres) {
  1242.      /* TW: Paranoia check */
  1243.         var->yres_virtual = var->yres;
  1244.     }
  1245. }
  1246. TWDEBUG("end of check_var");
  1247. return 0;
  1248. }
  1249. #endif
  1251. /* -------- functions for all series ------- */
  1253. static int sisfb_get_fix(struct fb_fix_screeninfo *fix, int con,
  1254.  struct fb_info *info)
  1255. {
  1256. TWDEBUG("inside get_fix");
  1257. memset(fix, 0, sizeof(struct fb_fix_screeninfo));
  1259. strcpy(fix->id, sis_fb_info.modename);
  1261. fix->smem_start = ivideo.video_base;
  1263.         /* TW */
  1264.         if((!sisfb_mem) || (sisfb_mem > (ivideo.video_size/1024))) {
  1265.     if (ivideo.video_size > 0x1000000) {
  1266.         fix->smem_len = 0xc00000;
  1267.     } else if (ivideo.video_size > 0x800000)
  1268. fix->smem_len = 0x800000;
  1269.     else
  1270. fix->smem_len = 0x400000;
  1271.         } else
  1272. fix->smem_len = sisfb_mem * 1024;
  1274. fix->type        = video_type;
  1275. fix->type_aux    = 0;
  1276. if(ivideo.video_bpp == 8)
  1277. fix->visual = FB_VISUAL_PSEUDOCOLOR;
  1278. else
  1279. fix->visual = FB_VISUAL_TRUECOLOR;
  1280. fix->xpanstep    = 0;
  1281. #ifdef SISFB_PAN
  1282.         if(sisfb_ypan)   fix->ypanstep = 1;
  1283. #endif
  1284. fix->ywrapstep   = 0;
  1285. fix->line_length = ivideo.video_linelength;
  1286. fix->mmio_start  = ivideo.mmio_base;
  1287. fix->mmio_len    = sisfb_mmio_size;
  1288. fix->accel       = FB_ACCEL_SIS_GLAMOUR;
  1289. fix->reserved[0] = ivideo.video_size & 0xFFFF;
  1290. fix->reserved[1] = (ivideo.video_size >> 16) & 0xFFFF;
  1291. fix->reserved[2] = sisfb_caps;
  1292. TWDEBUG("end of get_fix");
  1293. return 0;
  1294. }
  1296. static int sisfb_get_var(struct fb_var_screeninfo *var, int con,
  1297.  struct fb_info *info)
  1298. {
  1299. TWDEBUG("inside get_var");
  1300. if(con == -1)
  1301. memcpy(var, &default_var, sizeof(struct fb_var_screeninfo));
  1302. else
  1303. *var = fb_display[con].var;
  1305. /* JennyLee 2001126: for FSTN */
  1306. if (var->xres == 320 && var->yres == 480)
  1307. var->yres = 240;
  1308. /* ~JennyLee */
  1309. TWDEBUG("end of get_var");
  1310. return 0;
  1311. }
  1313. #ifdef SISFB_PAN
  1314. static int sisfb_pan_display(struct fb_var_screeninfo *var, int con,
  1315. struct fb_info* info)
  1316. {
  1317. #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,23)
  1318. #define currcon info->currcon
  1319. #endif
  1320. TWDEBUG("inside pan_display");
  1321. if (var->vmode & FB_VMODE_YWRAP) {
  1322. if (var->yoffset < 0 || var->yoffset >= fb_display[con].var.yres_virtual || var->xoffset)
  1323. return -EINVAL;
  1324. } else {
  1325. if (var->xoffset+fb_display[con].var.xres > fb_display[con].var.xres_virtual ||
  1326.     var->yoffset+fb_display[con].var.yres > fb_display[con].var.yres_virtual)
  1327. return -EINVAL;
  1328. }
  1330.         if (con == currcon)
  1331. sisfb_pan_var(var);
  1333. fb_display[con].var.xoffset = var->xoffset;
  1334. fb_display[con].var.yoffset = var->yoffset;
  1335. if (var->vmode & FB_VMODE_YWRAP)
  1336. fb_display[con].var.vmode |= FB_VMODE_YWRAP;
  1337. else
  1338. fb_display[con].var.vmode &= ~FB_VMODE_YWRAP;
  1340. TWDEBUG("end of pan_display");
  1341. return 0;
  1342. #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,23)
  1343. #undef currcon
  1344. #endif
  1345. }
  1346. #endif
  1348. static int sisfb_ioctl(struct inode *inode, struct file *file,
  1349.        unsigned int cmd, unsigned long arg, int con,
  1350.        struct fb_info *info)
  1351. {
  1352. TWDEBUG("inside ioctl");
  1353. switch (cmd) {
  1354.    case FBIO_ALLOC:
  1355. if (!capable(CAP_SYS_RAWIO))
  1356. return -EPERM;
  1357. sis_malloc((struct sis_memreq *) arg);
  1358. break;
  1359.    case FBIO_FREE:
  1360. if (!capable(CAP_SYS_RAWIO))
  1361. return -EPERM;
  1362. sis_free(*(unsigned long *) arg);
  1363. break;
  1364.    case FBIOGET_GLYPH:
  1365.                 sis_get_glyph(info,(SIS_GLYINFO *) arg);
  1366. break;
  1367.    case FBIOGET_HWCINFO:
  1368. {
  1369. unsigned long *hwc_offset = (unsigned long *) arg;
  1371. if (sisfb_caps & HW_CURSOR_CAP)
  1372. *hwc_offset = sisfb_hwcursor_vbase -
  1373.     (unsigned long) ivideo.video_vbase;
  1374. else
  1375. *hwc_offset = 0;
  1377. break;
  1378. }
  1379.    case FBIOPUT_MODEINFO:
  1380. {
  1381. struct mode_info *x = (struct mode_info *)arg;
  1383. ivideo.video_bpp        = x->bpp;
  1384. ivideo.video_width      = x->xres;
  1385. ivideo.video_height     = x->yres;
  1386. ivideo.video_vwidth     = x->v_xres;
  1387. ivideo.video_vheight    = x->v_yres;
  1388. ivideo.org_x            = x->org_x;
  1389. ivideo.org_y            = x->org_y;
  1390. ivideo.refresh_rate     = x->vrate;
  1391. ivideo.video_linelength = ivideo.video_width * (ivideo.video_bpp >> 3);
  1392. switch(ivideo.video_bpp) {
  1393.          case 8:
  1394.              ivideo.DstColor = 0x0000;
  1395.      ivideo.SiS310_AccelDepth = 0x00000000;
  1396. ivideo.video_cmap_len = 256;
  1397.              break;
  1398.          case 16:
  1399.              ivideo.DstColor = 0x8000;
  1400.              ivideo.SiS310_AccelDepth = 0x00010000;
  1401. ivideo.video_cmap_len = 16;
  1402.              break;
  1403.          case 32:
  1404.              ivideo.DstColor = 0xC000;
  1405.      ivideo.SiS310_AccelDepth = 0x00020000;
  1406. ivideo.video_cmap_len = 16;
  1407.              break;
  1408. default:
  1409. ivideo.video_cmap_len = 16;
  1410.           printk(KERN_ERR "sisfb: Unsupported accel depth %d", ivideo.video_bpp);
  1411. break;
  1412.      }
  1414. break;
  1415. }
  1416.    case FBIOGET_DISPINFO:
  1417. sis_dispinfo((struct ap_data *)arg);
  1418. break;
  1419.    case SISFB_GET_INFO:  /* TW: New for communication with X driver */
  1420.         {
  1421. sisfb_info *x = (sisfb_info *)arg;
  1423. x->sisfb_id = SISFB_ID;
  1424. x->sisfb_version = VER_MAJOR;
  1425. x->sisfb_revision = VER_MINOR;
  1426. x->sisfb_patchlevel = VER_LEVEL;
  1427. x->chip_id = ivideo.chip_id;
  1428. x->memory = ivideo.video_size / 1024;
  1429. x->heapstart = ivideo.heapstart / 1024;
  1430. x->fbvidmode = sisfb_mode_no;
  1431. x->sisfb_caps = sisfb_caps;
  1432. x->sisfb_tqlen = 512; /* yet unused */
  1433.                 break;
  1434. }
  1435.    default:
  1436. return -EINVAL;
  1437. }
  1438. TWDEBUG("end of ioctl");
  1439. return 0;
  1441. }
  1443. static int sisfb_mmap(struct fb_info *info, struct file *file,
  1444.       struct vm_area_struct *vma)
  1445. {
  1446. #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,23)
  1447. #define currcon info->currcon
  1448. #endif
  1449. struct fb_var_screeninfo var;
  1450. unsigned long start;
  1451. unsigned long off;
  1452. u32 len;
  1454. TWDEBUG("inside mmap");
  1455. if(vma->vm_pgoff > (~0UL >> PAGE_SHIFT))  return -EINVAL;
  1457. off = vma->vm_pgoff << PAGE_SHIFT;
  1459. start = (unsigned long) ivideo.video_base;
  1460. len = PAGE_ALIGN((start & ~PAGE_MASK) + ivideo.video_size);
  1462. if (off >= len) {
  1463. off -= len;
  1464. sisfb_get_var(&var, currcon, info);
  1465. if(var.accel_flags) return -EINVAL;
  1467. start = (unsigned long) ivideo.mmio_base;
  1468. len = PAGE_ALIGN((start & ~PAGE_MASK) + sisfb_mmio_size);
  1469. }
  1471. start &= PAGE_MASK;
  1472. if((vma->vm_end - vma->vm_start + off) > len) return -EINVAL;
  1474. off += start;
  1475. vma->vm_pgoff = off >> PAGE_SHIFT;
  1477. #if defined(__i386__) || defined(__x86_64__)
  1478. if (boot_cpu_data.x86 > 3)
  1479. pgprot_val(vma->vm_page_prot) |= _PAGE_PCD;
  1480. #endif
  1481. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
  1482. if (io_remap_page_range(vma->vm_start, off, vma->vm_end - vma->vm_start,
  1483. vma->vm_page_prot))
  1484. #else /* TW: 2.5 API */
  1485. if (io_remap_page_range(vma, vma->vm_start, off, vma->vm_end - vma->vm_start,
  1486. vma->vm_page_prot))
  1487. #endif
  1488. return -EAGAIN;
  1490.         TWDEBUG("end of mmap");
  1491. return 0;
  1492. #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,23)
  1493. #undef currcon
  1494. #endif
  1495. }
  1497. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,34)
  1498. static struct fb_ops sisfb_ops = {
  1499. .owner        = THIS_MODULE,
  1500. .fb_set_var   = gen_set_var,
  1501. .fb_get_cmap  = gen_get_cmap,
  1502. .fb_set_cmap  = gen_set_cmap,
  1504. .fb_check_var = sisfb_check_var,
  1505. .fb_set_par   = sisfb_set_par,
  1506.         .fb_setcolreg = sisfb_setcolreg,
  1507.         .fb_blank     = sisfb_blank,
  1508. #ifdef SISFB_PAN
  1509.         .fb_pan_display = sisfb_pan_display,
  1510. #endif
  1511.         .fb_fillrect  = fbcon_sis_fillrect,
  1512. .fb_copyarea  = fbcon_sis_copyarea,
  1513. .fb_imageblit = my_cfb_imageblit,
  1514. .fb_ioctl     = sisfb_ioctl,
  1515. .fb_mmap      = sisfb_mmap,
  1516. };
  1517. #endif
  1519. #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,5,33)
  1520. static struct fb_ops sisfb_ops = {
  1521. owner: THIS_MODULE,
  1522. fb_get_fix: sisfb_get_fix,
  1523. fb_get_var: sisfb_get_var,
  1524. fb_set_var: sisfb_set_var,
  1525. fb_get_cmap: sisfb_get_cmap,
  1526. fb_set_cmap: sisfb_set_cmap,
  1527. #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,23)
  1528.         fb_setcolreg:   sisfb_setcolreg,
  1529.         fb_blank:       sisfb_blank,
  1530. #endif
  1531. #ifdef SISFB_PAN
  1532.         fb_pan_display: sisfb_pan_display,
  1533. #endif
  1534. fb_ioctl: sisfb_ioctl,
  1535. fb_mmap: sisfb_mmap,
  1536. };
  1537. #endif
  1539. /* ------------ Interface to the low level console driver -------------*/
  1541. #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,5,33) /* --------- for 2.4 series --------- */
  1542. static int sisfb_update_var(int con, struct fb_info *info)
  1543. {
  1544. #ifdef SISFB_PAN
  1545.         sisfb_pan_var(&fb_display[con].var);
  1546. #endif
  1547. return 0;
  1548. }
  1550. static int sisfb_switch(int con, struct fb_info *info)
  1551. {
  1552. int cols, rows;
  1553. #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,23)
  1554. #define currcon info->currcon
  1555. #endif
  1557.         if(fb_display[currcon].cmap.len)
  1558. fb_get_cmap(&fb_display[currcon].cmap, 1, sis_getcolreg, info);
  1560. fb_display[con].var.activate = FB_ACTIVATE_NOW;
  1562. if(!memcmp(&fb_display[con].var, &fb_display[currcon].var,
  1563.                            sizeof(struct fb_var_screeninfo))) {
  1564. currcon = con;
  1565. return 1;
  1566. }
  1568. currcon = con;
  1570. sisfb_do_set_var(&fb_display[con].var, 1, info);
  1572. sisfb_set_disp(con, &fb_display[con].var, info);
  1574. sisfb_do_install_cmap(con, info);
  1576. cols = sisbios_mode[sisfb_mode_idx].cols;
  1577. rows = sisbios_mode[sisfb_mode_idx].rows;
  1578. vc_resize_con(rows, cols, fb_display[con].conp->vc_num);
  1580. sisfb_update_var(con, info);
  1582. return 1;
  1583. #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,23)
  1584. #undef currcon
  1585. #endif
  1586. }
  1588. static void sisfb_blank(int blank, struct fb_info *info)
  1589. {
  1590. u8 reg;
  1592. inSISIDXREG(SISCR, 0x17, reg);
  1594. if(blank > 0)
  1595. reg &= 0x7f;
  1596. else
  1597. reg |= 0x80;
  1599. outSISIDXREG(SISCR, 0x17, reg);
  1600. }
  1601. #endif
  1603. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,34) /* ---------- for 2.5 series -------- */
  1604. static int sisfb_blank(int blank, struct fb_info *info)
  1605. {
  1606. u8 reg;
  1608. inSISIDXREG(SISCR, 0x17, reg);
  1610. if(blank > 0)
  1611. reg &= 0x7f;
  1612. else
  1613. reg |= 0x80;
  1615. outSISIDXREG(SISCR, 0x17, reg);
  1616.         return(0);
  1617. }
  1618. #endif
  1620. /* --------------- Chip-dependent Routines --------------------------- */
  1622. #ifdef CONFIG_FB_SIS_300 /* for SiS 300/630/540/730 */
  1624. static int sisfb_get_dram_size_300(void)
  1625. {
  1626. struct pci_dev *pdev = NULL;
  1627. int pdev_valid = 0;
  1628. u8  pci_data, reg;
  1629. u16 nbridge_id;
  1631. switch (ivideo.chip) {
  1632.    case SIS_540:
  1633. nbridge_id = PCI_DEVICE_ID_SI_540;
  1634. break;
  1635.    case SIS_630:
  1636. nbridge_id = PCI_DEVICE_ID_SI_630;
  1637. break;
  1638.    case SIS_730:
  1639. nbridge_id = PCI_DEVICE_ID_SI_730;
  1640. break;
  1641.    default:
  1642. nbridge_id = 0;
  1643. break;
  1644. }
  1646. if (nbridge_id == 0) {  /* 300 */
  1648.         inSISIDXREG(SISSR, IND_SIS_DRAM_SIZE,reg);
  1649. ivideo.video_size =
  1650.         ((unsigned int) ((reg & SIS_DRAM_SIZE_MASK) + 1) << 20);
  1652. } else { /* 540, 630, 730 */
  1654. pci_for_each_dev(pdev) {
  1656. if ((pdev->vendor == PCI_VENDOR_ID_SI) 
  1657.        && (pdev->device == nbridge_id)) {
  1658. pci_read_config_byte(pdev, IND_BRI_DRAM_STATUS, &pci_data);
  1659. pci_data = (pci_data & BRI_DRAM_SIZE_MASK) >> 4;
  1660. ivideo.video_size = (unsigned int)(1 << (pci_data+21));
  1661. pdev_valid = 1;
  1663. reg = SIS_DATA_BUS_64 << 6;
  1664. switch (pci_data) {
  1665.    case BRI_DRAM_SIZE_2MB:
  1666. reg |= SIS_DRAM_SIZE_2MB;
  1667. break;
  1668.    case BRI_DRAM_SIZE_4MB:
  1669. reg |= SIS_DRAM_SIZE_4MB;
  1670. break;
  1671.    case BRI_DRAM_SIZE_8MB:
  1672. reg |= SIS_DRAM_SIZE_8MB;
  1673. break;
  1674.    case BRI_DRAM_SIZE_16MB:
  1675. reg |= SIS_DRAM_SIZE_16MB;
  1676. break;
  1677.    case BRI_DRAM_SIZE_32MB:
  1678. reg |= SIS_DRAM_SIZE_32MB;
  1679. break;
  1680.    case BRI_DRAM_SIZE_64MB:
  1681. reg |= SIS_DRAM_SIZE_64MB;
  1682. break;
  1683. }
  1684. outSISIDXREG(SISSR, IND_SIS_DRAM_SIZE, reg);
  1685. break;
  1686. }  
  1687. }   
  1689. if (!pdev_valid)  return -1;
  1690. }
  1691. return 0;
  1692. }
  1694. static void sisfb_detect_VB_connect_300()
  1695. {
  1696. u8 sr16, sr17, cr32, temp;
  1698. ivideo.TV_plug = ivideo.TV_type = 0;
  1700.         switch(ivideo.hasVB) {
  1701.   case HASVB_LVDS_CHRONTEL:
  1702.   case HASVB_CHRONTEL:
  1703.      SiS_SenseCh();
  1704.      break;
  1705.   case HASVB_301:
  1706.   case HASVB_302:
  1707.      SiS_Sense30x();
  1708.      break;
  1709. }
  1711. inSISIDXREG(SISSR, IND_SIS_SCRATCH_REG_17, sr17);
  1712.         inSISIDXREG(SISCR, IND_SIS_SCRATCH_REG_CR32, cr32);
  1714. if ((sr17 & 0x0F) && (ivideo.chip != SIS_300)) {
  1716. if ((sr17 & 0x01) && !sisfb_crt1off)
  1717. sisfb_crt1off = 0;
  1718. else {
  1719. if (sr17 & 0x0E)
  1720. sisfb_crt1off = 1;
  1721. else
  1722. sisfb_crt1off = 0;
  1723. }
  1725. if (sisfb_crt2type != -1)
  1726. /* TW: override detected CRT2 type */
  1727. ivideo.disp_state = sisfb_crt2type;
  1728. else if (sr17 & 0x08 )
  1729. ivideo.disp_state = DISPTYPE_CRT2;
  1730. else if (sr17 & 0x02)
  1731. ivideo.disp_state = DISPTYPE_LCD;
  1732. else if (sr17 & 0x04)
  1733. ivideo.disp_state = DISPTYPE_TV;
  1734. else
  1735. ivideo.disp_state = 0;
  1737. if(sisfb_tvplug != -1)
  1738. /* PR/TW: override detected TV type */
  1739. ivideo.TV_plug = sisfb_tvplug;
  1740. else if (sr17 & 0x20)
  1741. ivideo.TV_plug = TVPLUG_SVIDEO;
  1742. else if (sr17 & 0x10)
  1743. ivideo.TV_plug = TVPLUG_COMPOSITE;
  1745. inSISIDXREG(SISSR, IND_SIS_SCRATCH_REG_16, sr16);
  1746. if (sr16 & 0x20)
  1747. ivideo.TV_type = TVMODE_PAL;
  1748. else
  1749. ivideo.TV_type = TVMODE_NTSC;
  1751. } else {
  1753. if ((cr32 & SIS_CRT1) && !sisfb_crt1off)
  1754. sisfb_crt1off = 0;
  1755. else {
  1756. if (cr32 & 0x5F)
  1757. sisfb_crt1off = 1;
  1758. else
  1759. sisfb_crt1off = 0;
  1760. }
  1762. if (sisfb_crt2type != -1)
  1763. /* TW: override detected CRT2 type */
  1764. ivideo.disp_state = sisfb_crt2type;
  1765. else if (cr32 & SIS_VB_CRT2)
  1766. ivideo.disp_state = DISPTYPE_CRT2;
  1767. else if (cr32 & SIS_VB_LCD)
  1768. ivideo.disp_state = DISPTYPE_LCD;
  1769. else if (cr32 & SIS_VB_TV)
  1770. ivideo.disp_state = DISPTYPE_TV;
  1771. else
  1772. ivideo.disp_state = 0;
  1774. /* TW: Detect TV plug & type */
  1775. if(sisfb_tvplug != -1)
  1776. /* PR/TW: override with option */
  1777.         ivideo.TV_plug = sisfb_tvplug;
  1778. #ifdef oldHV
  1779. else if (cr32 & SIS_VB_HIVISION) {
  1780. ivideo.TV_type = TVMODE_HIVISION;
  1781. ivideo.TV_plug = TVPLUG_SVIDEO;
  1782. }
  1783. #endif
  1784. else if (cr32 & SIS_VB_SVIDEO)
  1785. ivideo.TV_plug = TVPLUG_SVIDEO;
  1786. else if (cr32 & SIS_VB_COMPOSITE)
  1787. ivideo.TV_plug = TVPLUG_COMPOSITE;
  1788. else if (cr32 & SIS_VB_SCART)
  1789. ivideo.TV_plug = TVPLUG_SCART;
  1791. if (ivideo.TV_type == 0) {
  1792.         inSISIDXREG(SISSR, IND_SIS_POWER_ON_TRAP, temp);
  1793. if (temp & 0x01)
  1794. ivideo.TV_type = TVMODE_PAL;
  1795. else
  1796. ivideo.TV_type = TVMODE_NTSC;
  1797. }
  1799. }
  1801. /* TW: Copy forceCRT1 option to CRT1off if option is given */
  1802.      if (sisfb_forcecrt1 != -1) {
  1803.      if(sisfb_forcecrt1) sisfb_crt1off = 0;
  1804. else                sisfb_crt1off = 1;
  1805.      }
  1806. }
  1808. static void sisfb_get_VB_type_300(void)
  1809. {
  1810. u8 reg;
  1812. if(ivideo.chip != SIS_300) {
  1813. if(!sisfb_has_VB_300()) {
  1814.         inSISIDXREG(SISCR, IND_SIS_SCRATCH_REG_CR37, reg);
  1815. switch ((reg & SIS_EXTERNAL_CHIP_MASK) >> 1) {
  1816.    case SIS_EXTERNAL_CHIP_SIS301:
  1817. ivideo.hasVB = HASVB_301;
  1818. break;
  1819.    case SIS_EXTERNAL_CHIP_LVDS:
  1820. ivideo.hasVB = HASVB_LVDS;
  1821. break;
  1822.    case SIS_EXTERNAL_CHIP_TRUMPION:
  1823. ivideo.hasVB = HASVB_TRUMPION;
  1824. break;
  1825.    case SIS_EXTERNAL_CHIP_LVDS_CHRONTEL:
  1826. ivideo.hasVB = HASVB_LVDS_CHRONTEL;
  1827. break;
  1828.    case SIS_EXTERNAL_CHIP_CHRONTEL:
  1829. ivideo.hasVB = HASVB_CHRONTEL;
  1830. break;
  1831.    default:
  1832. break;
  1833. }
  1834. }
  1835. } else {
  1836. sisfb_has_VB_300();
  1837. }
  1838. }
  1840. static int sisfb_has_VB_300(void)
  1841. {
  1842. u8 vb_chipid;
  1844. inSISIDXREG(SISPART4, 0x00, vb_chipid);
  1845. switch (vb_chipid) {
  1846.    case 0x01:
  1847. ivideo.hasVB = HASVB_301;
  1848. break;
  1849.    case 0x02:
  1850. ivideo.hasVB = HASVB_302;
  1851. break;
  1852.    case 0x03:
  1853. ivideo.hasVB = HASVB_303;
  1854. break;
  1855.    default:
  1856. ivideo.hasVB = HASVB_NONE;
  1857. return FALSE;
  1858. }
  1859. return TRUE;
  1861. }
  1863. #endif  /* CONFIG_FB_SIS_300 */
  1866. #ifdef CONFIG_FB_SIS_315    /* for SiS 315/550/650/740 */
  1868. static int sisfb_get_dram_size_315(void)
  1869. {
  1870. struct pci_dev *pdev = NULL;
  1871. int pdev_valid = 0;
  1872. u8  pci_data;
  1873. u8  reg = 0;
  1875. if (ivideo.chip == SIS_550 || ivideo.chip == SIS_650) {
  1877. #ifdef LINUXBIOS
  1879. pci_for_each_dev(pdev) {
  1881. if ( (pdev->vendor == PCI_VENDOR_ID_SI)
  1882. && ( (pdev->device == PCI_DEVICE_ID_SI_550) ||
  1883.      (pdev->device == PCI_DEVICE_ID_SI_650))) {
  1884. pci_read_config_byte(pdev, IND_BRI_DRAM_STATUS,
  1885.                      &pci_data);
  1886. pci_data = (pci_data & BRI_DRAM_SIZE_MASK) >> 4;
  1887. ivideo.video_size = (unsigned int)(1 << (pci_data + 21));
  1888. pdev_valid = 1;
  1890. /* TW: Initialize SR14 "by hand" */
  1891. inSISIDXREG(SISSR, IND_SIS_DRAM_SIZE, reg);
  1892. reg &= 0xC0;
  1893. switch (pci_data) {
  1894.    case BRI_DRAM_SIZE_4MB:
  1895. reg |= SIS550_DRAM_SIZE_4MB;
  1896. break;
  1897.    case BRI_DRAM_SIZE_8MB:
  1898. reg |= SIS550_DRAM_SIZE_8MB;
  1899. break;
  1900.    case BRI_DRAM_SIZE_16MB:
  1901. reg |= SIS550_DRAM_SIZE_16MB;
  1902. break;
  1903.    case BRI_DRAM_SIZE_32MB:
  1904. reg |= SIS550_DRAM_SIZE_32MB;
  1905. break;
  1906.    case BRI_DRAM_SIZE_64MB:
  1907. reg |= SIS550_DRAM_SIZE_64MB;
  1908. break;
  1909. }
  1911.         /* TODO: set Dual channel and bus width bits here */
  1913. outSISIDXREG(SISSR, IND_SIS_DRAM_SIZE, reg);
  1914. break;
  1915. }  
  1916. }
  1918. if (!pdev_valid)  return -1;
  1920. #else
  1922.                 inSISIDXREG(SISSR, IND_SIS_DRAM_SIZE, reg);
  1923. switch (reg & SIS550_DRAM_SIZE_MASK) {
  1924.    case SIS550_DRAM_SIZE_4MB:
  1925. ivideo.video_size = 0x400000;   break;
  1926.    case SIS550_DRAM_SIZE_8MB:
  1927. ivideo.video_size = 0x800000;   break;
  1928.    case SIS550_DRAM_SIZE_16MB:
  1929. ivideo.video_size = 0x1000000;  break;
  1930.    case SIS550_DRAM_SIZE_24MB:
  1931. ivideo.video_size = 0x1800000;  break;
  1932.    case SIS550_DRAM_SIZE_32MB:
  1933. ivideo.video_size = 0x2000000; break;
  1934.    case SIS550_DRAM_SIZE_64MB:
  1935. ivideo.video_size = 0x4000000; break;
  1936.    case SIS550_DRAM_SIZE_96MB:
  1937. ivideo.video_size = 0x6000000; break;
  1938.    case SIS550_DRAM_SIZE_128MB:
  1939. ivideo.video_size = 0x8000000; break;
  1940.    case SIS550_DRAM_SIZE_256MB:
  1941. ivideo.video_size = 0x10000000; break;
  1942.    default:
  1943.         /* TW: Some 550 BIOSes don't seem to initialize SR14 correctly (if at all),
  1944.  *     do it the hard way ourselves in this case. Unfortunately, we don't
  1945.  *     support 24, 48, 96 and other "odd" amounts here.
  1946.  */
  1947.         printk(KERN_INFO
  1948.        "sisfb: Warning: Could not determine memory size, "
  1949.        "now reading from PCI confign");
  1950. pdev_valid = 0;
  1952. pci_for_each_dev(pdev) {
  1954.    if ( (pdev->vendor == PCI_VENDOR_ID_SI)
  1955.          && (pdev->device == PCI_DEVICE_ID_SI_550) ) {
  1957. pci_read_config_byte(pdev, IND_BRI_DRAM_STATUS,
  1958.                      &pci_data);
  1959. pci_data = (pci_data & BRI_DRAM_SIZE_MASK) >> 4;
  1960. ivideo.video_size = (unsigned int)(1 << (pci_data+21));
  1961. pdev_valid = 1;
  1962. /* TW: Initialize SR14=IND_SIS_DRAM_SIZE */
  1963. inSISIDXREG(SISSR, IND_SIS_DRAM_SIZE, reg);
  1964. reg &= 0xC0;
  1965. switch (pci_data) {
  1966.    case BRI_DRAM_SIZE_4MB:
  1967. reg |= SIS550_DRAM_SIZE_4MB;  break;
  1968.    case BRI_DRAM_SIZE_8MB:
  1969. reg |= SIS550_DRAM_SIZE_8MB;  break;
  1970.    case BRI_DRAM_SIZE_16MB:
  1971. reg |= SIS550_DRAM_SIZE_16MB; break;
  1972.    case BRI_DRAM_SIZE_32MB:
  1973. reg |= SIS550_DRAM_SIZE_32MB; break;
  1974.    case BRI_DRAM_SIZE_64MB:
  1975. reg |= SIS550_DRAM_SIZE_64MB; break;
  1976.    default:
  1977.     printk(KERN_INFO "sisfb: Unable to determine memory size, giving up.n");
  1978. return -1;
  1979. }
  1980. outSISIDXREG(SISSR, IND_SIS_DRAM_SIZE, reg);
  1981.    }
  1982. }
  1983. if (!pdev_valid) {
  1984. printk(KERN_INFO "sisfb: Total confusion - No SiS PCI VGA device found?!n");
  1985. return -1;
  1986. }
  1987. return 0;
  1988. }
  1989. #endif
  1990. return 0;
  1992. } else { /* 315 */
  1994.         inSISIDXREG(SISSR, IND_SIS_DRAM_SIZE, reg);
  1995. switch ((reg & SIS315_DRAM_SIZE_MASK) >> 4) {
  1996.    case SIS315_DRAM_SIZE_2MB:
  1997. ivideo.video_size = 0x200000;
  1998. break;
  1999.    case SIS315_DRAM_SIZE_4MB:
  2000. ivideo.video_size = 0x400000;
  2001. break;
  2002.    case SIS315_DRAM_SIZE_8MB:
  2003. ivideo.video_size = 0x800000;
  2004. break;
  2005.    case SIS315_DRAM_SIZE_16MB:
  2006. ivideo.video_size = 0x1000000;
  2007. break;
  2008.    case SIS315_DRAM_SIZE_32MB:
  2009. ivideo.video_size = 0x2000000;
  2010. break;
  2011.    case SIS315_DRAM_SIZE_64MB:
  2012. ivideo.video_size = 0x4000000;
  2013. break;
  2014.    case SIS315_DRAM_SIZE_128MB:
  2015. ivideo.video_size = 0x8000000;
  2016. break;
  2017.    default:
  2018. return -1;
  2019. }
  2020. }
  2022. reg &= SIS315_DUAL_CHANNEL_MASK;
  2023. reg >>= 2;
  2024. switch (reg) {
  2025.    case SIS315_SINGLE_CHANNEL_2_RANK:
  2026. ivideo.video_size <<= 1;
  2027. break;
  2028.    case SIS315_DUAL_CHANNEL_1_RANK:
  2029. ivideo.video_size <<= 1;
  2030. break;
  2031.    case SIS315_ASYM_DDR: /* TW: DDR asymentric */
  2032. ivideo.video_size += (ivideo.video_size/2);
  2033. break;
  2034. }
  2036. return 0;
  2037. }
  2039. static void sisfb_detect_VB_connect_315(void)
  2040. {
  2041. u8 cr32, temp=0;
  2043. ivideo.TV_plug = ivideo.TV_type = 0;
  2045.         switch(ivideo.hasVB) {
  2046.   case HASVB_LVDS_CHRONTEL:
  2047.   case HASVB_CHRONTEL:
  2048.      SiS_SenseCh();
  2049.      break;
  2050.   case HASVB_301:
  2051.   case HASVB_302:
  2052.      SiS_Sense30x();
  2053.      break;
  2054. }
  2056. inSISIDXREG(SISCR, IND_SIS_SCRATCH_REG_CR32, cr32);
  2058. if ((cr32 & SIS_CRT1) && !sisfb_crt1off)
  2059. sisfb_crt1off = 0;
  2060. else {
  2061. if (cr32 & 0x5F)   
  2062. sisfb_crt1off = 1;
  2063. else
  2064. sisfb_crt1off = 0;
  2065. }
  2067. if (sisfb_crt2type != -1)
  2068. /* TW: Override with option */
  2069. ivideo.disp_state = sisfb_crt2type;
  2070. else if (cr32 & SIS_VB_CRT2)
  2071. ivideo.disp_state = DISPTYPE_CRT2;
  2072. else if (cr32 & SIS_VB_LCD)
  2073. ivideo.disp_state = DISPTYPE_LCD;
  2074. else if (cr32 & SIS_VB_TV)
  2075. ivideo.disp_state = DISPTYPE_TV;
  2076. else
  2077. ivideo.disp_state = 0;
  2079. if(sisfb_tvplug != -1)
  2080. /* PR/TW: Override with option */
  2081.         ivideo.TV_plug = sisfb_tvplug;
  2082. #ifdef oldHV
  2083. else if (cr32 & SIS_VB_HIVISION) {
  2084. ivideo.TV_type = TVMODE_HIVISION;
  2085. ivideo.TV_plug = TVPLUG_SVIDEO;
  2086. }
  2087. #endif
  2088. else if (cr32 & SIS_VB_SVIDEO)
  2089. ivideo.TV_plug = TVPLUG_SVIDEO;
  2090. else if (cr32 & SIS_VB_COMPOSITE)
  2091. ivideo.TV_plug = TVPLUG_COMPOSITE;
  2092. else if (cr32 & SIS_VB_SCART)
  2093. ivideo.TV_plug = TVPLUG_SCART;
  2095. if(ivideo.TV_type == 0) {
  2096.     /* TW: PAL/NTSC changed for 650 */
  2097.     if(ivideo.chip <= SIS_315PRO) {
  2099.                 inSISIDXREG(SISCR, 0x38, temp);
  2100. if(temp & 0x10)
  2101. ivideo.TV_type = TVMODE_PAL;
  2102. else
  2103. ivideo.TV_type = TVMODE_NTSC;
  2105.     } else {
  2107.         inSISIDXREG(SISCR, 0x79, temp);
  2108. if(temp & 0x20)
  2109. ivideo.TV_type = TVMODE_PAL;
  2110. else
  2111. ivideo.TV_type = TVMODE_NTSC;
  2112.     }
  2113. }
  2115. /* TW: Copy forceCRT1 option to CRT1off if option is given */
  2116.      if (sisfb_forcecrt1 != -1) {
  2117.      if (sisfb_forcecrt1) sisfb_crt1off = 0;
  2118. else                 sisfb_crt1off = 1;
  2119.      }
  2120. }
  2122. static void sisfb_get_VB_type_315(void)
  2123. {
  2124. u8 reg;
  2126. if (!sisfb_has_VB_315()) {
  2127.         inSISIDXREG(SISCR, IND_SIS_SCRATCH_REG_CR37, reg);
  2128. /* TW: CR37 changed on 310/325 series */
  2129. switch ((reg & SIS_EXTERNAL_CHIP_MASK) >> 1) {
  2130.    case SIS_EXTERNAL_CHIP_SIS301:
  2131. ivideo.hasVB = HASVB_301;
  2132. break;
  2133.    case SIS310_EXTERNAL_CHIP_LVDS:
  2134. ivideo.hasVB = HASVB_LVDS;
  2135. break;
  2136.    case SIS310_EXTERNAL_CHIP_LVDS_CHRONTEL:
  2137. ivideo.hasVB = HASVB_LVDS_CHRONTEL;
  2138. break;
  2139.    default:
  2140. break;
  2141. }
  2142. }
  2143. }
  2146. static int sisfb_has_VB_315(void)
  2147. {
  2148. u8 vb_chipid;
  2150. inSISIDXREG(SISPART4, 0x00, vb_chipid);
  2151. switch (vb_chipid) {
  2152.    case 0x01:
  2153. ivideo.hasVB = HASVB_301;
  2154. break;
  2155.    case 0x02:
  2156. ivideo.hasVB = HASVB_302;
  2157. break;
  2158.    case 0x03:
  2159. ivideo.hasVB = HASVB_303;
  2160. break;
  2161.    default:
  2162. ivideo.hasVB = HASVB_NONE;
  2163. return FALSE;
  2164. }
  2165. return TRUE;
  2166. }
  2168. #endif   /* CONFIG_FB_SIS_315 */
  2170. /* -------------- Sensing routines --------------- */
  2172. /* TW: Determine and detect attached devices on SiS30x */
  2173. int
  2174. SISDoSense(int tempbl, int tempbh, int tempcl, int tempch)
  2175. {
  2176.     int temp,i;
  2178.     outSISIDXREG(SISPART4,0x11,tempbl);
  2179.     temp = tempbh | tempcl;
  2180.     setSISIDXREG(SISPART4,0x10,0xe0,temp);
  2181.     for(i=0; i<10; i++) SiS_LongWait(&SiS_Pr);
  2182.     tempch &= 0x7f;
  2183.     inSISIDXREG(SISPART4,0x03,temp);
  2184.     temp ^= 0x0e;
  2185.     temp &= tempch;
  2186.     return(temp);
  2187. }
  2189. void
  2190. SiS_Sense30x(void)
  2191. {
  2192.   u8 backupP4_0d;
  2193.   u8 testsvhs_tempbl, testsvhs_tempbh;
  2194.   u8 testsvhs_tempcl, testsvhs_tempch;
  2195.   u8 testcvbs_tempbl, testcvbs_tempbh;
  2196.   u8 testcvbs_tempcl, testcvbs_tempch;
  2197.   int myflag, result;
  2199.   inSISIDXREG(SISPART4,0x0d,backupP4_0d);
  2200.   outSISIDXREG(SISPART4,0x0d,(backupP4_0d | 0x04));
  2202.   if(sisvga_engine == SIS_300_VGA) {
  2204.         testsvhs_tempbh = 0x00; testsvhs_tempbl = 0xb9;
  2205. testcvbs_tempbh = 0x00; testcvbs_tempbl = 0xb3;
  2206. if((sishw_ext.ujVBChipID != VB_CHIP_301) &&
  2207.    (sishw_ext.ujVBChipID != VB_CHIP_302) ) {
  2208.    testsvhs_tempbh = 0x01; testsvhs_tempbl = 0x6b;
  2209.    testcvbs_tempbh = 0x01; testcvbs_tempbl = 0x74;
  2210. }
  2211. inSISIDXREG(SISPART4,0x01,myflag);
  2212. if(myflag & 0x04) {
  2213.    testsvhs_tempbh = 0x00; testsvhs_tempbl = 0xdd;
  2214.    testcvbs_tempbh = 0x00; testcvbs_tempbl = 0xee;
  2215. }
  2216. testsvhs_tempch = 0x06; testsvhs_tempcl = 0x04;
  2217. testcvbs_tempch = 0x08; testcvbs_tempcl = 0x04;
  2219.   } else if((ivideo.chip == SIS_315) ||
  2220.          (ivideo.chip == SIS_315H) ||
  2221.     (ivideo.chip == SIS_315PRO)) {
  2223.         testsvhs_tempbh = 0x00; testsvhs_tempbl = 0xb9;
  2224. testcvbs_tempbh = 0x00; testcvbs_tempbl = 0xb3;
  2225. if((sishw_ext.ujVBChipID != VB_CHIP_301) &&
  2226.    (sishw_ext.ujVBChipID != VB_CHIP_302) ) {
  2227.       testsvhs_tempbh = 0x01; testsvhs_tempbl = 0x6b;
  2228.       testcvbs_tempbh = 0x01; testcvbs_tempbl = 0x74;
  2229. }
  2230. inSISIDXREG(SISPART4,0x01,myflag);
  2231. if(myflag & 0x04) {
  2232.    testsvhs_tempbh = 0x00; testsvhs_tempbl = 0xdd;
  2233.    testcvbs_tempbh = 0x00; testcvbs_tempbl = 0xee;
  2234. }
  2235. testsvhs_tempch = 0x06; testsvhs_tempcl = 0x04;
  2236. testcvbs_tempch = 0x08; testcvbs_tempcl = 0x04;
  2238.     } else {
  2240.         testsvhs_tempbh = 0x02; testsvhs_tempbl = 0x00;
  2241. testcvbs_tempbh = 0x01; testcvbs_tempbl = 0x00;
  2243. testsvhs_tempch = 0x04; testsvhs_tempcl = 0x08;
  2244. testcvbs_tempch = 0x08; testcvbs_tempcl = 0x08;
  2246.     }
  2248.     result = SISDoSense(testsvhs_tempbl, testsvhs_tempbh,
  2249.                         testsvhs_tempcl, testsvhs_tempch);
  2250.     if(result) {
  2251.         printk(KERN_INFO "sisfb: Detected TV connected to SVHS outputn");
  2252.         /* TW: So we can be sure that there IS a SVHS output */
  2253. ivideo.TV_plug = TVPLUG_SVIDEO;
  2254. orSISIDXREG(SISCR, 0x32, 0x02);
  2255.     }
  2257.     if(!result) {
  2258.         result = SISDoSense(testcvbs_tempbl, testcvbs_tempbh,
  2259.                     testcvbs_tempcl, testcvbs_tempch);
  2260. if(result) {
  2261.     printk(KERN_INFO "sisfb: Detected TV connected to CVBS outputn");
  2262.     /* TW: So we can be sure that there IS a CVBS output */
  2263.     ivideo.TV_plug = TVPLUG_COMPOSITE;
  2264.     orSISIDXREG(SISCR, 0x32, 0x01);
  2265. }
  2266.     }
  2267.     SISDoSense(0, 0, 0, 0);
  2269.     outSISIDXREG(SISPART4,0x0d,backupP4_0d);
  2270. }
  2272. /* TW: Determine and detect attached TV's on Chrontel */
  2273. void
  2274. SiS_SenseCh(void)
  2275. {
  2277.    u8 temp1;
  2278. #ifdef CONFIG_FB_SIS_315
  2279.    u8 temp2;
  2280. #endif
  2282.    if(ivideo.chip < SIS_315H) {
  2284. #ifdef CONFIG_FB_SIS_300
  2285.        SiS_Pr.SiS_IF_DEF_CH70xx = 1; /* TW: Chrontel 7005 */
  2286.        temp1 = SiS_GetCH700x(&SiS_Pr, 0x25);
  2287.        if ((temp1 >= 50) && (temp1 <= 100)) {
  2288.    /* TW: Read power status */
  2289.    temp1 = SiS_GetCH700x(&SiS_Pr, 0x0e);
  2290.    if((temp1 & 0x03) != 0x03) {
  2291.               /* TW: Power all outputs */
  2292. SiS_SetCH70xxANDOR(&SiS_Pr, 0x030E,0xF8);
  2293.    }
  2294.    /* TW: Sense connected TV devices */
  2295.    SiS_SetCH700x(&SiS_Pr, 0x0110);
  2296.    SiS_SetCH700x(&SiS_Pr, 0x0010);
  2297.    temp1 = SiS_GetCH700x(&SiS_Pr, 0x10);
  2298.    if(!(temp1 & 0x08)) {
  2299. printk(KERN_INFO
  2300.    "sisfb: Chrontel: Detected TV connected to SVHS outputn");
  2301. /* TW: So we can be sure that there IS a SVHS output */
  2302. ivideo.TV_plug = TVPLUG_SVIDEO;
  2303. orSISIDXREG(SISCR, 0x32, 0x02);
  2304.    } else if (!(temp1 & 0x02)) {
  2305. printk(KERN_INFO
  2306.    "sisfb: Chrontel: Detected TV connected to CVBS outputn");
  2307. /* TW: So we can be sure that there IS a CVBS output */
  2308. ivideo.TV_plug = TVPLUG_COMPOSITE;
  2309. orSISIDXREG(SISCR, 0x32, 0x01);
  2310.    } else {
  2311.   SiS_SetCH70xxANDOR(&SiS_Pr, 0x010E,0xF8);
  2312.    }
  2313.        } else if(temp1 == 0) {
  2314.   SiS_SetCH70xxANDOR(&SiS_Pr, 0x010E,0xF8);
  2315.        }
  2316. #endif
  2318.    } else {
  2320. #ifdef CONFIG_FB_SIS_315
  2321. SiS_Pr.SiS_IF_DEF_CH70xx = 2; /* TW: Chrontel 7019 */
  2322.         temp1 = SiS_GetCH701x(&SiS_Pr, 0x49);
  2323. SiS_SetCH701x(&SiS_Pr, 0x2049);
  2324. SiS_DDC2Delay(&SiS_Pr, 0x96);
  2325. temp2 = SiS_GetCH701x(&SiS_Pr, 0x20);
  2326. temp2 |= 0x01;
  2327. SiS_SetCH701x(&SiS_Pr, (temp2 << 8) | 0x20);
  2328. SiS_DDC2Delay(&SiS_Pr, 0x96);
  2329. temp2 ^= 0x01;
  2330. SiS_SetCH701x(&SiS_Pr, (temp2 << 8) | 0x20);
  2331. SiS_DDC2Delay(&SiS_Pr, 0x96);
  2332. temp2 = SiS_GetCH701x(&SiS_Pr, 0x20);
  2333. SiS_SetCH701x(&SiS_Pr, (temp1 << 8) | 0x49);
  2334.         temp1 = 0;
  2335. if(temp2 & 0x02) temp1 |= 0x01;
  2336. if(temp2 & 0x10) temp1 |= 0x01;
  2337. if(temp2 & 0x04) temp1 |= 0x02;
  2338. if( (temp1 & 0x01) && (temp1 & 0x02) ) temp1 = 0x04;
  2339. switch(temp1) {
  2340. case 0x01:
  2341.      printk(KERN_INFO
  2342. "sisfb: Chrontel: Detected TV connected to CVBS outputn");
  2343.      ivideo.TV_plug = TVPLUG_COMPOSITE;
  2344.      orSISIDXREG(SISCR, 0x32, 0x01);
  2345.              break;
  2346. case 0x02:
  2347.      printk(KERN_INFO
  2348. "sisfb: Chrontel: Detected TV connected to SVHS outputn");
  2349.      ivideo.TV_plug = TVPLUG_SVIDEO;
  2350.      orSISIDXREG(SISCR, 0x32, 0x02);
  2351.              break;
  2352. case 0x04:
  2353.      /* TW: This should not happen */
  2354.      printk(KERN_INFO
  2355. "sisfb: Chrontel: Detected TV connected to SCART output!?n");
  2356.              break;
  2357. }
  2358. #endif
  2360.    }
  2361. }
  2364. /* --------------------- Heap Routines ------------------------------- */
  2366. static int sisfb_heap_init(void)
  2367. {
  2368. SIS_OH *poh;
  2369. u8 temp=0;
  2370. #ifdef CONFIG_FB_SIS_315
  2371. int            agp_enabled = 1;
  2372. u32            agp_size;
  2373. unsigned long *cmdq_baseport = 0;
  2374. unsigned long *read_port = 0;
  2375. unsigned long *write_port = 0;
  2376. SIS_CMDTYPE    cmd_type;
  2377. #ifndef AGPOFF
  2378. agp_kern_info  *agp_info;
  2379. agp_memory     *agp;
  2380. u32            agp_phys;
  2381. #endif
  2382. #endif
  2383. /* TW: The heap start is either set manually using the "mem" parameter, or
  2384.  *     defaults as follows:
  2385.  *     -) If more than 16MB videoRAM available, let our heap start at 12MB.
  2386.  *     -) If more than  8MB videoRAM available, let our heap start at  8MB.
  2387.  *     -) If 4MB or less is available, let it start at 4MB.
  2388.  *     This is for avoiding a clash with X driver which uses the beginning
  2389.  *     of the videoRAM. To limit size of X framebuffer, use Option MaxXFBMem
  2390.  *     in XF86Config-4.
  2391.  *     The heap start can also be specified by parameter "mem" when starting the sisfb
  2392.  *     driver. sisfb mem=1024 lets heap starts at 1MB, etc.
  2393.  */
  2394.      if ((!sisfb_mem) || (sisfb_mem > (ivideo.video_size/1024))) {
  2395.         if (ivideo.video_size > 0x1000000) {
  2396.         ivideo.heapstart = 0xc00000;
  2397. } else if (ivideo.video_size > 0x800000) {
  2398.         ivideo.heapstart = 0x800000;
  2399. } else {
  2400. ivideo.heapstart = 0x400000;
  2401. }
  2402.      } else {
  2403.            ivideo.heapstart = sisfb_mem * 1024;
  2404.      }
  2405.      sisfb_heap_start =
  2406.        (unsigned long) (ivideo.video_vbase + ivideo.heapstart);
  2407.      printk(KERN_INFO "sisfb: Memory heap starting at %dKn",
  2408.       (int)(ivideo.heapstart / 1024));
  2410.      sisfb_heap_end = (unsigned long) ivideo.video_vbase + ivideo.video_size;
  2411.      sisfb_heap_size = sisfb_heap_end - sisfb_heap_start;
  2413. #ifdef CONFIG_FB_SIS_315
  2414.      if (sisvga_engine == SIS_315_VGA) {
  2415.         /* TW: Now initialize the 310 series' command queue mode.
  2416.  * On 310/325, there are three queue modes available which
  2417.  * are chosen by setting bits 7:5 in SR26:
  2418.  * 1. MMIO queue mode (bit 5, 0x20). The hardware will keep
  2419.  *    track of the queue, the FIFO, command parsing and so
  2420.  *    on. This is the one comparable to the 300 series.
  2421.  * 2. VRAM queue mode (bit 6, 0x40). In this case, one will
  2422.  *    have to do queue management himself. Register 0x85c4 will
  2423.  *    hold the location of the next free queue slot, 0x85c8
  2424.  *    is the "queue read pointer" whose way of working is
  2425.  *    unknown to me. Anyway, this mode would require a
  2426.  *    translation of the MMIO commands to some kind of
  2427.  *    accelerator assembly and writing these commands
  2428.  *    to the memory location pointed to by 0x85c4.
  2429.  *    We will not use this, as nobody knows how this
  2430.  *    "assembly" works, and as it would require a complete
  2431.  *    re-write of the accelerator code.
  2432.  * 3. AGP queue mode (bit 7, 0x80). Works as 2., but keeps the
  2433.  *    queue in AGP memory space.
  2434.  *
  2435.  * SR26 bit 4 is called "Bypass H/W queue".
  2436.  * SR26 bit 1 is called "Enable Command Queue Auto Correction"
  2437.  * SR26 bit 0 resets the queue
  2438.  * Size of queue memory is encoded in bits 3:2 like this:
  2439.  *    00  (0x00)  512K
  2440.  *    01  (0x04)  1M
  2441.  *    10  (0x08)  2M
  2442.  *    11  (0x0C)  4M
  2443.  * The queue location is to be written to 0x85C0.
  2444.  *
  2445.          */
  2446. cmdq_baseport = (unsigned long *)(ivideo.mmio_vbase + MMIO_QUEUE_PHYBASE);
  2447. write_port    = (unsigned long *)(ivideo.mmio_vbase + MMIO_QUEUE_WRITEPORT);
  2448. read_port     = (unsigned long *)(ivideo.mmio_vbase + MMIO_QUEUE_READPORT);
  2450. DPRINTK("AGP base: 0x%p, read: 0x%p, write: 0x%pn", cmdq_baseport, read_port, write_port);
  2452. agp_size  = COMMAND_QUEUE_AREA_SIZE;
  2454. #ifndef AGPOFF
  2455. if (sisfb_queuemode == AGP_CMD_QUEUE) {
  2456. agp_info = vmalloc(sizeof(agp_kern_info));
  2457. memset((void*)agp_info, 0x00, sizeof(agp_kern_info));
  2458. agp_copy_info(agp_info);
  2460. agp_backend_acquire();
  2462. agp = agp_allocate_memory(COMMAND_QUEUE_AREA_SIZE/PAGE_SIZE,
  2463.   AGP_NORMAL_MEMORY);
  2464. if (agp == NULL) {
  2465. DPRINTK("sisfb: Allocating AGP buffer failed.n");
  2466. agp_enabled = 0;
  2467. } else {
  2468. if (agp_bind_memory(agp, agp->pg_start) != 0) {
  2469. DPRINTK("sisfb: AGP: Failed to bind memoryn");
  2470. /* TODO: Free AGP memory here */
  2471. agp_enabled = 0;
  2472. } else {
  2473. agp_enable(0);
  2474. }
  2475. }
  2476. }
  2477. #else
  2478. agp_enabled = 0;
  2479. #endif
  2481. /* TW: Now select the queue mode */
  2483. if ((agp_enabled) && (sisfb_queuemode == AGP_CMD_QUEUE)) {
  2484. cmd_type = AGP_CMD_QUEUE;
  2485. printk(KERN_INFO "sisfb: Using AGP queue moden");
  2486. /* } else if (sisfb_heap_size >= COMMAND_QUEUE_AREA_SIZE)  */
  2487.         } else if (sisfb_queuemode == VM_CMD_QUEUE) {
  2488. cmd_type = VM_CMD_QUEUE;
  2489. printk(KERN_INFO "sisfb: Using VRAM queue moden");
  2490. } else {
  2491. printk(KERN_INFO "sisfb: Using MMIO queue moden");
  2492. cmd_type = MMIO_CMD;
  2493. }
  2495. switch (agp_size) {
  2496.    case 0x80000:
  2497. temp = SIS_CMD_QUEUE_SIZE_512k;
  2498. break;
  2499.    case 0x100000:
  2500. temp = SIS_CMD_QUEUE_SIZE_1M;
  2501. break;
  2502.    case 0x200000:
  2503. temp = SIS_CMD_QUEUE_SIZE_2M;
  2504. break;
  2505.    case 0x400000:
  2506. temp = SIS_CMD_QUEUE_SIZE_4M;
  2507. break;
  2508. }
  2510. switch (cmd_type) {
  2511.    case AGP_CMD_QUEUE:
  2512. #ifndef AGPOFF
  2513. DPRINTK("sisfb: AGP buffer base = 0x%lx, offset = 0x%x, size = %dKn",
  2514. agp_info->aper_base, agp->physical, agp_size/1024);
  2516. agp_phys = agp_info->aper_base + agp->physical;
  2518. outSISIDXREG(SISCR,  IND_SIS_AGP_IO_PAD, 0);
  2519. outSISIDXREG(SISCR,  IND_SIS_AGP_IO_PAD, SIS_AGP_2X);
  2521.                 outSISIDXREG(SISSR, IND_SIS_CMDQUEUE_THRESHOLD, COMMAND_QUEUE_THRESHOLD);
  2523. outSISIDXREG(SISSR, IND_SIS_CMDQUEUE_SET, SIS_CMD_QUEUE_RESET);
  2525. *write_port = *read_port;
  2527. temp |= SIS_AGP_CMDQUEUE_ENABLE;
  2528. outSISIDXREG(SISSR, IND_SIS_CMDQUEUE_SET, temp);
  2530. *cmdq_baseport = agp_phys;
  2532. sisfb_caps |= AGP_CMD_QUEUE_CAP;
  2533. #endif
  2534. break;
  2536.    case VM_CMD_QUEUE:
  2537. sisfb_heap_end -= COMMAND_QUEUE_AREA_SIZE;
  2538. sisfb_heap_size -= COMMAND_QUEUE_AREA_SIZE;
  2540. outSISIDXREG(SISSR, IND_SIS_CMDQUEUE_THRESHOLD, COMMAND_QUEUE_THRESHOLD);
  2542. outSISIDXREG(SISSR, IND_SIS_CMDQUEUE_SET, SIS_CMD_QUEUE_RESET);
  2544. *write_port = *read_port;
  2546. temp |= SIS_VRAM_CMDQUEUE_ENABLE;
  2547. outSISIDXREG(SISSR, IND_SIS_CMDQUEUE_SET, temp);
  2549. *cmdq_baseport = ivideo.video_size - COMMAND_QUEUE_AREA_SIZE;
  2551. sisfb_caps |= VM_CMD_QUEUE_CAP;
  2553. DPRINTK("sisfb: VM Cmd Queue offset = 0x%lx, size is %dKn",
  2554. *cmdq_baseport, COMMAND_QUEUE_AREA_SIZE/1024);
  2555. break;
  2557.    default:  /* MMIO */
  2558.     /* TW: This previously only wrote SIS_MMIO_CMD_ENABLE
  2559.  * to IND_SIS_CMDQUEUE_SET. I doubt that this is
  2560.  * enough. Reserve memory in any way.
  2561.  */
  2562.     sisfb_heap_end -= COMMAND_QUEUE_AREA_SIZE;
  2563. sisfb_heap_size -= COMMAND_QUEUE_AREA_SIZE;
  2565. outSISIDXREG(SISSR, IND_SIS_CMDQUEUE_THRESHOLD, COMMAND_QUEUE_THRESHOLD);
  2566. outSISIDXREG(SISSR, IND_SIS_CMDQUEUE_SET, SIS_CMD_QUEUE_RESET);
  2568. *write_port = *read_port;
  2570. /* TW: Set Auto_Correction bit */
  2571. temp |= (SIS_MMIO_CMD_ENABLE | SIS_CMD_AUTO_CORR);
  2572. outSISIDXREG(SISSR, IND_SIS_CMDQUEUE_SET, temp);
  2574. *cmdq_baseport = ivideo.video_size - COMMAND_QUEUE_AREA_SIZE;
  2576. sisfb_caps |= MMIO_CMD_QUEUE_CAP;
  2578. DPRINTK("sisfb: MMIO Cmd Queue offset = 0x%lx, size is %dKn",
  2579. *cmdq_baseport, COMMAND_QUEUE_AREA_SIZE/1024);
  2580. break;
  2581. }
  2582.      } /* sisvga_engine = 315 */
  2583. #endif
  2585. #ifdef CONFIG_FB_SIS_300
  2586.      if (sisvga_engine == SIS_300_VGA) {
  2587.        /* TW: Now initialize TurboQueue. TB is always located at the very
  2588.      * top of the video RAM. */
  2589.     if (sisfb_heap_size >= TURBO_QUEUE_AREA_SIZE) {
  2590. unsigned int  tqueue_pos;
  2591. u8 tq_state;
  2593. tqueue_pos = (ivideo.video_size -
  2594.        TURBO_QUEUE_AREA_SIZE) / (64 * 1024);
  2596. temp = (u8) (tqueue_pos & 0xff);
  2598. inSISIDXREG(SISSR, IND_SIS_TURBOQUEUE_SET, tq_state);
  2599. tq_state |= 0xf0;
  2600. tq_state &= 0xfc;
  2601. tq_state |= (u8) (tqueue_pos >> 8);
  2602. outSISIDXREG(SISSR, IND_SIS_TURBOQUEUE_SET, tq_state);
  2604. outSISIDXREG(SISSR, IND_SIS_TURBOQUEUE_ADR, temp);
  2606. sisfb_caps |= TURBO_QUEUE_CAP;
  2608. sisfb_heap_end -= TURBO_QUEUE_AREA_SIZE;
  2609. sisfb_heap_size -= TURBO_QUEUE_AREA_SIZE;
  2610. DPRINTK("sisfb: TurboQueue start at 0x%lx, size is %dKn",
  2611. sisfb_heap_end, TURBO_QUEUE_AREA_SIZE/1024);
  2612.     }
  2613.      }
  2614. #endif
  2615.      /* TW: Now reserve memory for the HWCursor. It is always located at the very
  2616.             top of the videoRAM, right below the TB memory area (if used). */
  2617.      if (sisfb_heap_size >= sisfb_hwcursor_size) {
  2618. sisfb_heap_end -= sisfb_hwcursor_size;
  2619. sisfb_heap_size -= sisfb_hwcursor_size;
  2620. sisfb_hwcursor_vbase = sisfb_heap_end;
  2622. sisfb_caps |= HW_CURSOR_CAP;
  2624. DPRINTK("sisfb: Hardware Cursor start at 0x%lx, size is %dKn",
  2625. sisfb_heap_end, sisfb_hwcursor_size/1024);
  2626.      }
  2628.      sisfb_heap.poha_chain = NULL;
  2629.      sisfb_heap.poh_freelist = NULL;
  2631.      poh = sisfb_poh_new_node();
  2633.      if(poh == NULL)  return 1;
  2635.      poh->poh_next = &sisfb_heap.oh_free;
  2636.      poh->poh_prev = &sisfb_heap.oh_free;
  2637.      poh->size = sisfb_heap_end - sisfb_heap_start + 1;
  2638.      poh->offset = sisfb_heap_start - (unsigned long) ivideo.video_vbase;
  2640.      DPRINTK("sisfb: Heap start:0x%p, end:0x%p, len=%dkn",
  2641. (char *) sisfb_heap_start, (char *) sisfb_heap_end,
  2642. (unsigned int) poh->size / 1024);
  2644.      DPRINTK("sisfb: First Node offset:0x%x, size:%dkn",
  2645. (unsigned int) poh->offset, (unsigned int) poh->size / 1024);
  2647.      sisfb_heap.oh_free.poh_next = poh;
  2648.      sisfb_heap.oh_free.poh_prev = poh;
  2649.      sisfb_heap.oh_free.size = 0;
  2650.      sisfb_heap.max_freesize = poh->size;
  2652.      sisfb_heap.oh_used.poh_next = &sisfb_heap.oh_used;
  2653.      sisfb_heap.oh_used.poh_prev = &sisfb_heap.oh_used;
  2654.      sisfb_heap.oh_used.size = SENTINEL;
  2656.      return 0;
  2657. }
  2659. static SIS_OH *sisfb_poh_new_node(void)
  2660. {
  2661. int           i;
  2662. unsigned long cOhs;
  2663. SIS_OHALLOC   *poha;
  2664. SIS_OH        *poh;
  2666. if (sisfb_heap.poh_freelist == NULL) {
  2667. poha = kmalloc(OH_ALLOC_SIZE, GFP_KERNEL);
  2668. if(!poha) return NULL;
  2670. poha->poha_next = sisfb_heap.poha_chain;
  2671. sisfb_heap.poha_chain = poha;
  2673. cOhs = (OH_ALLOC_SIZE - sizeof(SIS_OHALLOC)) / sizeof(SIS_OH) + 1;
  2675. poh = &poha->aoh[0];
  2676. for (i = cOhs - 1; i != 0; i--) {
  2677. poh->poh_next = poh + 1;
  2678. poh = poh + 1;
  2679. }
  2681. poh->poh_next = NULL;
  2682. sisfb_heap.poh_freelist = &poha->aoh[0];
  2683. }
  2685. poh = sisfb_heap.poh_freelist;
  2686. sisfb_heap.poh_freelist = poh->poh_next;
  2688. return (poh);
  2689. }
  2691. static SIS_OH *sisfb_poh_allocate(unsigned long size)
  2692. {
  2693. SIS_OH *pohThis;
  2694. SIS_OH *pohRoot;
  2695. int     bAllocated = 0;
  2697. if (size > sisfb_heap.max_freesize) {
  2698. DPRINTK("sisfb: Can't allocate %dk size on offscreenn",
  2699. (unsigned int) size / 1024);
  2700. return (NULL);
  2701. }
  2703. pohThis = sisfb_heap.oh_free.poh_next;
  2705. while (pohThis != &sisfb_heap.oh_free) {
  2706. if (size <= pohThis->size) {
  2707. bAllocated = 1;
  2708. break;
  2709. }
  2710. pohThis = pohThis->poh_next;
  2711. }
  2713. if (!bAllocated) {
  2714. DPRINTK("sisfb: Can't allocate %dk size on offscreenn",
  2715. (unsigned int) size / 1024);
  2716. return (NULL);
  2717. }
  2719. if (size == pohThis->size) {
  2720. pohRoot = pohThis;
  2721. sisfb_delete_node(pohThis);
  2722. } else {
  2723. pohRoot = sisfb_poh_new_node();
  2725. if (pohRoot == NULL) {
  2726. return (NULL);
  2727. }
  2729. pohRoot->offset = pohThis->offset;
  2730. pohRoot->size = size;
  2732. pohThis->offset += size;
  2733. pohThis->size -= size;
  2734. }
  2736. sisfb_heap.max_freesize -= size;
  2738. pohThis = &sisfb_heap.oh_used;
  2739. sisfb_insert_node(pohThis, pohRoot);
  2741. return (pohRoot);
  2742. }
  2744. static void sisfb_delete_node(SIS_OH *poh)
  2745. {
  2746. SIS_OH *poh_prev;
  2747. SIS_OH *poh_next;
  2749. poh_prev = poh->poh_prev;
  2750. poh_next = poh->poh_next;
  2752. poh_prev->poh_next = poh_next;
  2753. poh_next->poh_prev = poh_prev;
  2755. }
  2757. static void sisfb_insert_node(SIS_OH *pohList, SIS_OH *poh)
  2758. {
  2759. SIS_OH *pohTemp;
  2761. pohTemp = pohList->poh_next;
  2763. pohList->poh_next = poh;
  2764. pohTemp->poh_prev = poh;
  2766. poh->poh_prev = pohList;
  2767. poh->poh_next = pohTemp;
  2768. }
  2770. static SIS_OH *sisfb_poh_free(unsigned long base)
  2771. {
  2772. SIS_OH *pohThis;
  2773. SIS_OH *poh_freed;
  2774. SIS_OH *poh_prev;
  2775. SIS_OH *poh_next;
  2776. unsigned long ulUpper;
  2777. unsigned long ulLower;
  2778. int foundNode = 0;
  2780. poh_freed = sisfb_heap.oh_used.poh_next;
  2782. while(poh_freed != &sisfb_heap.oh_used) {
  2783. if(poh_freed->offset == base) {
  2784. foundNode = 1;
  2785. break;
  2786. }
  2788. poh_freed = poh_freed->poh_next;
  2789. }
  2791. if (!foundNode)  return (NULL);
  2793. sisfb_heap.max_freesize += poh_freed->size;
  2795. poh_prev = poh_next = NULL;
  2796. ulUpper = poh_freed->offset + poh_freed->size;
  2797. ulLower = poh_freed->offset;
  2799. pohThis = sisfb_heap.oh_free.poh_next;
  2801. while (pohThis != &sisfb_heap.oh_free) {
  2802. if (pohThis->offset == ulUpper) {
  2803. poh_next = pohThis;
  2804. }
  2805. else if ((pohThis->offset + pohThis->size) ==
  2806.  ulLower) {
  2807. poh_prev = pohThis;
  2808. }
  2809. pohThis = pohThis->poh_next;
  2810. }
  2812. sisfb_delete_node(poh_freed);
  2814. if (poh_prev && poh_next) {
  2815. poh_prev->size += (poh_freed->size + poh_next->size);
  2816. sisfb_delete_node(poh_next);
  2817. sisfb_free_node(poh_freed);
  2818. sisfb_free_node(poh_next);
  2819. return (poh_prev);
  2820. }
  2822. if (poh_prev) {
  2823. poh_prev->size += poh_freed->size;
  2824. sisfb_free_node(poh_freed);
  2825. return (poh_prev);
  2826. }
  2828. if (poh_next) {
  2829. poh_next->size += poh_freed->size;
  2830. poh_next->offset = poh_freed->offset;
  2831. sisfb_free_node(poh_freed);
  2832. return (poh_next);
  2833. }
  2835. sisfb_insert_node(&sisfb_heap.oh_free, poh_freed);
  2837. return (poh_freed);
  2838. }
  2840. static void sisfb_free_node(SIS_OH *poh)
  2841. {
  2842. if(poh == NULL) return;
  2844. poh->poh_next = sisfb_heap.poh_freelist;
  2845. sisfb_heap.poh_freelist = poh;
  2847. }
  2849. void sis_malloc(struct sis_memreq *req)
  2850. {
  2851. SIS_OH *poh;
  2853. poh = sisfb_poh_allocate(req->size);
  2855. if(poh == NULL) {
  2856. req->offset = 0;
  2857. req->size = 0;
  2858. DPRINTK("sisfb: Video RAM allocation failedn");
  2859. } else {
  2860. DPRINTK("sisfb: Video RAM allocation succeeded: 0x%pn",
  2861. (char *) (poh->offset + (unsigned long) ivideo.video_vbase));
  2863. req->offset = poh->offset;
  2864. req->size = poh->size;
  2865. }
  2867. }
  2869. void sis_free(unsigned long base)
  2870. {
  2871. SIS_OH *poh;
  2873. poh = sisfb_poh_free(base);
  2875. if(poh == NULL) {
  2876. DPRINTK("sisfb: sisfb_poh_free() failed at base 0x%xn",
  2877. (unsigned int) base);
  2878. }
  2879. }
  2881. /* ------------------ SetMode Routines ------------------------------- */
  2883. static void sisfb_pre_setmode(void)
  2884. {
  2885. u8 cr30 = 0, cr31 = 0;
  2887. inSISIDXREG(SISCR, 0x31, cr31);
  2888. cr31 &= ~0x60;
  2890. switch (ivideo.disp_state & DISPTYPE_DISP2) {
  2891.    case DISPTYPE_CRT2:
  2892. printk(KERN_INFO "sisfb: CRT2 type is VGAn");
  2893. cr30 = (SIS_VB_OUTPUT_CRT2 | SIS_SIMULTANEOUS_VIEW_ENABLE);
  2894. cr31 |= SIS_DRIVER_MODE;
  2895. break;
  2896.    case DISPTYPE_LCD:
  2897. printk(KERN_INFO "sisfb: CRT2 type is LCDn");
  2898. cr30  = (SIS_VB_OUTPUT_LCD | SIS_SIMULTANEOUS_VIEW_ENABLE);
  2899. cr31 |= SIS_DRIVER_MODE;
  2900. break;
  2901.    case DISPTYPE_TV:
  2902. printk(KERN_INFO "sisfb: CRT2 type is TVn");
  2903. if (ivideo.TV_type == TVMODE_HIVISION)
  2904. cr30 = (SIS_VB_OUTPUT_HIVISION | SIS_SIMULTANEOUS_VIEW_ENABLE);
  2905. else if (ivideo.TV_plug == TVPLUG_SVIDEO)
  2906. cr30 = (SIS_VB_OUTPUT_SVIDEO | SIS_SIMULTANEOUS_VIEW_ENABLE);
  2907. else if (ivideo.TV_plug == TVPLUG_COMPOSITE)
  2908. cr30 = (SIS_VB_OUTPUT_COMPOSITE | SIS_SIMULTANEOUS_VIEW_ENABLE);
  2909. else if (ivideo.TV_plug == TVPLUG_SCART)
  2910. cr30 = (SIS_VB_OUTPUT_SCART | SIS_SIMULTANEOUS_VIEW_ENABLE);
  2911. cr31 |= SIS_DRIVER_MODE;
  2913.         if (sisfb_tvmode == 1 || ivideo.TV_type == TVMODE_PAL)
  2914. cr31 |= 0x01;
  2915.                 else   /* if (sisfb_tvmode == 2 || ivideo.TV_type == TVMODE_NTSC) - nonsense */
  2916.                         cr31 &= ~0x01;
  2917. break;
  2918.    default: /* CRT2 disable */
  2919. printk(KERN_INFO "sisfb: CRT2 is disabledn");
  2920. cr30 = 0x00;
  2921. cr31 |= (SIS_DRIVER_MODE | SIS_VB_OUTPUT_DISABLE);
  2922. }
  2924. outSISIDXREG(SISCR, IND_SIS_SCRATCH_REG_CR30, cr30);
  2925. outSISIDXREG(SISCR, IND_SIS_SCRATCH_REG_CR31, cr31);
  2927.         outSISIDXREG(SISCR, IND_SIS_SCRATCH_REG_CR33, (sisfb_rate_idx & 0x0F));
  2929. }
  2931. static void sisfb_post_setmode(void)
  2932. {
  2933. u8 reg;
  2934. BOOLEAN doit = TRUE;
  2936. /* TW: We can't switch off CRT1 on LVDS/Chrontel in 8bpp Modes */
  2937. if ((ivideo.hasVB == HASVB_LVDS) || (ivideo.hasVB == HASVB_LVDS_CHRONTEL)) {
  2938. if (ivideo.video_bpp == 8) {
  2939. doit = FALSE;
  2940. }
  2941. }
  2943. /* TW: We can't switch off CRT1 on 630+301B in 8bpp Modes */
  2944. if ( (sishw_ext.ujVBChipID == VB_CHIP_301B) && (sisvga_engine == SIS_300_VGA) &&
  2945.      (ivideo.disp_state & DISPTYPE_LCD) ) {
  2946.         if (ivideo.video_bpp == 8) {
  2947. doit = FALSE;
  2948.         }
  2949. }
  2951. /* TW: We can't switch off CRT1 if bridge is in slave mode */
  2952. if(ivideo.hasVB != HASVB_NONE) {
  2953. inSISIDXREG(SISPART1, 0x00, reg);
  2954. if(sisvga_engine == SIS_300_VGA) {
  2955. if((reg & 0xa0) == 0x20) {
  2956. doit = FALSE;
  2957. }
  2958. }
  2959. if(sisvga_engine == SIS_315_VGA) {
  2960. if((reg & 0x50) == 0x10) {
  2961. doit = FALSE;
  2962. }
  2963. }
  2964. } else sisfb_crt1off = 0;
  2966. inSISIDXREG(SISCR, 0x17, reg);
  2967. if((sisfb_crt1off) && (doit))
  2968. reg &= ~0x80;
  2969. else        
  2970. reg |= 0x80;
  2971. outSISIDXREG(SISCR, 0x17, reg);
  2973.         andSISIDXREG(SISSR, IND_SIS_RAMDAC_CONTROL, ~0x04);
  2975. if((ivideo.disp_state & DISPTYPE_TV) && (ivideo.hasVB == HASVB_301)) {
  2977.    inSISIDXREG(SISPART4, 0x01, reg);
  2979.    if(reg < 0xB0) {         /* Set filter for SiS301 */
  2981. switch (ivideo.video_width) {
  2982.    case 320:
  2983. filter_tb = (ivideo.TV_type == TVMODE_NTSC) ? 4 : 12;
  2984. break;
  2985.    case 640:
  2986. filter_tb = (ivideo.TV_type == TVMODE_NTSC) ? 5 : 13;
  2987. break;
  2988.    case 720:
  2989. filter_tb = (ivideo.TV_type == TVMODE_NTSC) ? 6 : 14;
  2990. break;
  2991.    case 800:
  2992. filter_tb = (ivideo.TV_type == TVMODE_NTSC) ? 7 : 15;
  2993. break;
  2994.    default:
  2995. filter = -1;
  2996. break;
  2997. }
  2999. orSISIDXREG(SISPART1, sisfb_CRT2_write_enable, 0x01);
  3001. if(ivideo.TV_type == TVMODE_NTSC) {
  3003.         andSISIDXREG(SISPART2, 0x3a, 0x1f);
  3005. if (ivideo.TV_plug == TVPLUG_SVIDEO) {
  3007.         andSISIDXREG(SISPART2, 0x30, 0xdf);
  3009. } else if (ivideo.TV_plug == TVPLUG_COMPOSITE) {
  3011.         orSISIDXREG(SISPART2, 0x30, 0x20);
  3013. switch (ivideo.video_width) {
  3014. case 640:
  3015.         outSISIDXREG(SISPART2, 0x35, 0xEB);
  3016. outSISIDXREG(SISPART2, 0x36, 0x04);
  3017. outSISIDXREG(SISPART2, 0x37, 0x25);
  3018. outSISIDXREG(SISPART2, 0x38, 0x18);
  3019. break;
  3020. case 720:
  3021. outSISIDXREG(SISPART2, 0x35, 0xEE);
  3022. outSISIDXREG(SISPART2, 0x36, 0x0C);
  3023. outSISIDXREG(SISPART2, 0x37, 0x22);
  3024. outSISIDXREG(SISPART2, 0x38, 0x08);
  3025. break;
  3026. case 800:
  3027. outSISIDXREG(SISPART2, 0x35, 0xEB);
  3028. outSISIDXREG(SISPART2, 0x36, 0x15);
  3029. outSISIDXREG(SISPART2, 0x37, 0x25);
  3030. outSISIDXREG(SISPART2, 0x38, 0xF6);
  3031. break;
  3032. }
  3033. }
  3035. } else if(ivideo.TV_type == TVMODE_PAL) {
  3037. andSISIDXREG(SISPART2, 0x3A, 0x1F);
  3039. if (ivideo.TV_plug == TVPLUG_SVIDEO) {
  3041.         andSISIDXREG(SISPART2, 0x30, 0xDF);
  3043. } else if (ivideo.TV_plug == TVPLUG_COMPOSITE) {
  3045.         orSISIDXREG(SISPART2, 0x30, 0x20);
  3047. switch (ivideo.video_width) {
  3048. case 640:
  3049. outSISIDXREG(SISPART2, 0x35, 0xF1);
  3050. outSISIDXREG(SISPART2, 0x36, 0xF7);
  3051. outSISIDXREG(SISPART2, 0x37, 0x1F);
  3052. outSISIDXREG(SISPART2, 0x38, 0x32);
  3053. break;
  3054. case 720:
  3055. outSISIDXREG(SISPART2, 0x35, 0xF3);
  3056. outSISIDXREG(SISPART2, 0x36, 0x00);
  3057. outSISIDXREG(SISPART2, 0x37, 0x1D);
  3058. outSISIDXREG(SISPART2, 0x38, 0x20);
  3059. break;
  3060. case 800:
  3061. outSISIDXREG(SISPART2, 0x35, 0xFC);
  3062. outSISIDXREG(SISPART2, 0x36, 0xFB);
  3063. outSISIDXREG(SISPART2, 0x37, 0x14);
  3064. outSISIDXREG(SISPART2, 0x38, 0x2A);
  3065. break;
  3066. }
  3067. }
  3068. }
  3070. if ((filter >= 0) && (filter <=7)) {
  3071. DPRINTK("FilterTable[%d]-%d: %02x %02x %02x %02xn", filter_tb, filter, 
  3072. sis_TV_filter[filter_tb].filter[filter][0],
  3073. sis_TV_filter[filter_tb].filter[filter][1],
  3074. sis_TV_filter[filter_tb].filter[filter][2],
  3075. sis_TV_filter[filter_tb].filter[filter][3]
  3076. );
  3077. outSISIDXREG(SISPART2, 0x35, (sis_TV_filter[filter_tb].filter[filter][0]));
  3078. outSISIDXREG(SISPART2, 0x36, (sis_TV_filter[filter_tb].filter[filter][1]));
  3079. outSISIDXREG(SISPART2, 0x37, (sis_TV_filter[filter_tb].filter[filter][2]));
  3080. outSISIDXREG(SISPART2, 0x38, (sis_TV_filter[filter_tb].filter[filter][3]));
  3081. }
  3083.      }
  3084.   
  3085. }
  3087. }
  3089. #ifndef MODULE
  3090. int sisfb_setup(char *options)
  3091. {
  3092. char *this_opt;
  3094. sis_fb_info.fontname[0] = '';
  3095. ivideo.refresh_rate = 0;
  3097.         printk(KERN_INFO "sisfb: Options %sn", options);
  3099. if (!options || !*options)
  3100. return 0;
  3102. while((this_opt = strsep(&options, ",")) != NULL) {
  3104. if (!*this_opt) continue;
  3106. if (!strcmp(this_opt, "inverse")) {
  3107. sisfb_inverse = 1;
  3108. /* fb_invert_cmaps(); */
  3109. } else if (!strncmp(this_opt, "font:", 5)) {
  3110. strcpy(sis_fb_info.fontname, this_opt + 5);
  3111. } else if (!strncmp(this_opt, "mode:", 5)) {
  3112. sisfb_search_mode(this_opt + 5);
  3113. } else if (!strncmp(this_opt, "vesa:", 5)) {
  3114. sisfb_search_vesamode(simple_strtoul(this_opt + 5, NULL, 0));
  3115. } else if (!strncmp(this_opt, "vrate:", 6)) {
  3116. ivideo.refresh_rate =
  3117.     simple_strtoul(this_opt + 6, NULL, 0);
  3118. } else if (!strncmp(this_opt, "rate:", 5)) {
  3119. ivideo.refresh_rate =
  3120.     simple_strtoul(this_opt + 5, NULL, 0);
  3121. } else if (!strncmp(this_opt, "off", 3)) {
  3122. sisfb_off = 1;
  3123. } else if (!strncmp(this_opt, "crt1off", 7)) {
  3124. sisfb_crt1off = 1;
  3125. } else if (!strncmp(this_opt, "filter:", 7)) {
  3126. filter = (int)simple_strtoul(this_opt + 7, NULL, 0);
  3127. } else if (!strncmp(this_opt, "forcecrt2type:", 14)) {
  3128. sisfb_search_crt2type(this_opt + 14);
  3129. } else if (!strncmp(this_opt, "forcecrt1:", 10)) {
  3130. sisfb_forcecrt1 = (int)simple_strtoul(this_opt + 10, NULL, 0);
  3131.                 } else if (!strncmp(this_opt, "tvmode:",7)) {
  3132.                         if (!strncmp(this_opt + 7, "pal",3))
  3133.                           sisfb_tvmode = 1;
  3134.                         if (!strncmp(this_opt + 7, "ntsc",4))
  3135.                           sisfb_tvmode = 2;
  3136.                 } else if (!strncmp(this_opt, "tvstandard:",11)) {
  3137.                         if (!strncmp(this_opt + 11, "pal",3))
  3138.                           sisfb_tvmode = 1;
  3139.                         else if (!strncmp(this_opt + 11, "ntsc",4))
  3140.                           sisfb_tvmode = 2;
  3141.                 }else if (!strncmp(this_opt, "mem:",4)) {
  3142.         sisfb_mem = simple_strtoul(this_opt + 4, NULL, 0);
  3143.                 } else if (!strncmp(this_opt, "dstn", 4)) {
  3144. enable_dstn = 1;
  3145. /* TW: DSTN overrules forcecrt2type */
  3146. sisfb_crt2type = DISPTYPE_LCD;
  3147. } else if (!strncmp(this_opt, "queuemode:", 10)) {
  3148. sisfb_search_queuemode(this_opt + 10);
  3149. } else if (!strncmp(this_opt, "pdc:", 4)) {
  3150.         sisfb_pdc = simple_strtoul(this_opt + 4, NULL, 0);
  3151.         if(sisfb_pdc & ~0x3c) {
  3152.    printk(KERN_INFO "sisfb: Illegal pdc parametern");
  3153.    sisfb_pdc = 0;
  3154.         }
  3155. } else if (!strncmp(this_opt, "noaccel", 7)) {
  3156. sisfb_accel = 0;
  3157. } else if (!strncmp(this_opt, "noypan", 6)) {
  3158.         sisfb_ypan = 0;
  3159. } else {
  3160. printk(KERN_INFO "sisfb: Invalid parameter %sn", this_opt);
  3161. }
  3163. /* TW: Acceleration only with MMIO mode */
  3164. if((sisfb_queuemode != -1) && (sisfb_queuemode != MMIO_CMD)) {
  3165. sisfb_ypan = 0;
  3166. sisfb_accel = 0;
  3167. }
  3168. /* TW: Panning only with acceleration */
  3169. if(sisfb_accel == 0) sisfb_ypan = 0;
  3171. }
  3172. return 0;
  3173. }
  3174. #endif
  3176. int __init sisfb_init(void)
  3177. {
  3178. struct pci_dev *pdev = NULL;
  3179. struct board *b;
  3180. int pdev_valid = 0;
  3181. /* unsigned long rom_vbase;  */
  3182. u32 reg32;
  3183. u16 reg16;
  3184. u8  reg;
  3186. outb(0x77, 0x80);
  3188. #if 0 
  3189. /* for DOC VB */
  3190. sisfb_set_reg4(0xcf8,0x800000e0);
  3191. reg32 = sisfb_get_reg3(0xcfc);
  3192. reg32 = reg32 | 0x00001000;
  3193. sisfb_set_reg4(0xcfc,reg32);
  3194. }
  3195. #endif
  3197. if (sisfb_off)
  3198. return -ENXIO;
  3200. if (enable_dstn)
  3201. SetEnableDstn(&SiS_Pr);
  3203. memset(&sis_fb_info, 0, sizeof(sis_fb_info));
  3204. memset(&sis_disp, 0, sizeof(sis_disp));
  3206. pci_for_each_dev(pdev) {
  3207. for (b = sisdev_list; b->vendor; b++) {
  3208. if ((b->vendor == pdev->vendor)
  3209.     && (b->device == pdev->device)) {
  3210. pdev_valid = 1;
  3211. strcpy(sis_fb_info.modename, b->name);
  3212. ivideo.chip_id = pdev->device;
  3213. pci_read_config_byte(pdev, PCI_REVISION_ID,
  3214.                      &ivideo.revision_id);
  3215. pci_read_config_word(pdev, PCI_COMMAND, &reg16);
  3216. sishw_ext.jChipRevision = ivideo.revision_id;
  3217. sisvga_enabled = reg16 & 0x01;
  3218. break;
  3219. }
  3220. }
  3222. if (pdev_valid)
  3223. break;
  3224. }
  3226. if (!pdev_valid)
  3227. return -ENODEV;
  3229. switch (ivideo.chip_id) {
  3230.    case PCI_DEVICE_ID_SI_300:
  3231. ivideo.chip = SIS_300;
  3232. sisvga_engine = SIS_300_VGA;
  3233. sisfb_hwcursor_size = HW_CURSOR_AREA_SIZE_300;
  3234. sisfb_CRT2_write_enable = IND_SIS_CRT2_WRITE_ENABLE_300;
  3235. break;
  3236.    case PCI_DEVICE_ID_SI_630_VGA:
  3237. {
  3238. sisfb_set_reg4(0xCF8, 0x80000000);
  3239. reg32 = sisfb_get_reg3(0xCFC);
  3240. if(reg32 == 0x07301039) {
  3241. ivideo.chip = SIS_730;
  3242. strcpy(sis_fb_info.modename, "SIS 730");
  3243. } else
  3244. ivideo.chip = SIS_630;
  3246. sisvga_engine = SIS_300_VGA;
  3247. sisfb_hwcursor_size = HW_CURSOR_AREA_SIZE_300;
  3248. sisfb_CRT2_write_enable = IND_SIS_CRT2_WRITE_ENABLE_300;
  3249. break;
  3250. }
  3251.    case PCI_DEVICE_ID_SI_540_VGA:
  3252. ivideo.chip = SIS_540;
  3253. sisvga_engine = SIS_300_VGA;
  3254. sisfb_hwcursor_size = HW_CURSOR_AREA_SIZE_300;
  3255. sisfb_CRT2_write_enable = IND_SIS_CRT2_WRITE_ENABLE_300;
  3256. break;
  3257.    case PCI_DEVICE_ID_SI_315H:
  3258. ivideo.chip = SIS_315H;
  3259. sisvga_engine = SIS_315_VGA;
  3260. sisfb_hwcursor_size = HW_CURSOR_AREA_SIZE_315;
  3261. sisfb_CRT2_write_enable = IND_SIS_CRT2_WRITE_ENABLE_315;
  3262. break;
  3263.    case PCI_DEVICE_ID_SI_315:
  3264. ivideo.chip = SIS_315;
  3265. sisvga_engine = SIS_315_VGA;
  3266. sisfb_hwcursor_size = HW_CURSOR_AREA_SIZE_315;
  3267. sisfb_CRT2_write_enable = IND_SIS_CRT2_WRITE_ENABLE_315;
  3268. break;
  3269.    case PCI_DEVICE_ID_SI_315PRO:
  3270. ivideo.chip = SIS_315PRO;
  3271. sisvga_engine = SIS_315_VGA;
  3272. sisfb_hwcursor_size = HW_CURSOR_AREA_SIZE_315;
  3273. sisfb_CRT2_write_enable = IND_SIS_CRT2_WRITE_ENABLE_315;
  3274. break;
  3275.    case PCI_DEVICE_ID_SI_550_VGA:
  3276. ivideo.chip = SIS_550;
  3277. sisvga_engine = SIS_315_VGA;
  3278. sisfb_hwcursor_size = HW_CURSOR_AREA_SIZE_315;
  3279. sisfb_CRT2_write_enable = IND_SIS_CRT2_WRITE_ENABLE_315;
  3280. break;
  3281.    case PCI_DEVICE_ID_SI_650_VGA:
  3282. ivideo.chip = SIS_650;
  3283. sisvga_engine = SIS_315_VGA;
  3284. sisfb_hwcursor_size = HW_CURSOR_AREA_SIZE_315;
  3285. sisfb_CRT2_write_enable = IND_SIS_CRT2_WRITE_ENABLE_315;
  3286. break;
  3287. }
  3288. sishw_ext.jChipType = ivideo.chip;
  3290. /* for Debug */
  3291. if ((sishw_ext.jChipType == SIS_315PRO) 
  3292.    || (sishw_ext.jChipType == SIS_315) )
  3293. sishw_ext.jChipType = SIS_315H;
  3295. DPRINTK("%s is used as %s device (VGA Engine %d).n",
  3296. sis_fb_info.modename, sisvga_enabled ? "primary" : "secondary", sisvga_engine);
  3298. ivideo.video_base = pci_resource_start(pdev, 0);
  3299. ivideo.mmio_base = pci_resource_start(pdev, 1);
  3300. sishw_ext.ulIOAddress = (unsigned short) ivideo.vga_base =
  3301.     (unsigned short) SiS_Pr.RelIO = pci_resource_start(pdev, 2) + 0x30;
  3303. sisfb_mmio_size =  pci_resource_len(pdev, 1);
  3305. if(!sisvga_enabled) {
  3306. if (pci_enable_device(pdev))   return -EIO;
  3307. }
  3309. SiSRegInit(&SiS_Pr, (USHORT)sishw_ext.ulIOAddress);
  3311. // Eden Eden
  3312. //#ifdef LINUXBIOS
  3313. // sishw_ext.VirtualRomBase = rom_vbase = (unsigned long) rom_data;
  3314. //#else
  3315. // {
  3316. // unsigned long rom_base  = 0x000C0000;
  3317. //
  3318. // request_region(rom_base, 32, "sisfb");
  3319. // sishw_ext.VirtualRomBase = rom_vbase 
  3320. // = (unsigned long) ioremap(rom_base, MAX_ROM_SCAN);
  3321. // }
  3322. //#endif
  3323. // ~Eden Chen
  3325.         outSISIDXREG(SISSR, IND_SIS_PASSWORD, SIS_PASSWORD);
  3327. #ifdef LINUXBIOS
  3329. #ifdef CONFIG_FB_SIS_300
  3330. if (sisvga_engine == SIS_300_VGA) {
  3331.         outSISIDXREG(SISSR, 0x28, 0x37);
  3333.                 outSISIDXREG(SISSR, 0x29, 0x61);
  3335.                 orSISIDXREG(SISSR, IND_SIS_SCRATCH_REG_1A, SIS_SCRATCH_REG_1A_MASK);
  3336. }
  3337. #endif
  3338. #ifdef CONFIG_FB_SIS_315
  3339. if (ivideo.chip == SIS_550 || ivideo.chip == SIS_650) {
  3340.         outSISIDXREG(SISSR, 0x28, 0x5a);
  3342.                 outSISIDXREG(SISSR, 0x29, 0x64);
  3344.                 outSISIDXREG(SISCR, 0x3a, 0x00);
  3345. }
  3346. #endif
  3348. #endif /* LinuxBIOS */
  3350. if (sisvga_engine == SIS_315_VGA) {
  3351. switch (ivideo.chip) {
  3352.    case SIS_315H:
  3353.    case SIS_315:
  3354. sishw_ext.bIntegratedMMEnabled = TRUE;
  3355. break;
  3356.    case SIS_550:
  3357.    case SIS_650:
  3358. sishw_ext.bIntegratedMMEnabled = TRUE;
  3359. break;
  3360.    default:
  3361. break;
  3362. }
  3363. } else if (sisvga_engine == SIS_300_VGA) {
  3364. if (ivideo.chip == SIS_300) {
  3365. sishw_ext.bIntegratedMMEnabled = TRUE;
  3366. } else {
  3367.         inSISIDXREG(SISSR, IND_SIS_SCRATCH_REG_1A, reg);
  3368. if (reg & SIS_SCRATCH_REG_1A_MASK)
  3369. sishw_ext.bIntegratedMMEnabled = TRUE;
  3370. else
  3371. sishw_ext.bIntegratedMMEnabled = FALSE;
  3372. }
  3373. }
  3375. sishw_ext.pDevice = NULL;
  3376. sishw_ext.pjVirtualRomBase = NULL;
  3377. sishw_ext.pjCustomizedROMImage = NULL;
  3378. sishw_ext.bSkipDramSizing = 0;
  3379. sishw_ext.pQueryVGAConfigSpace = &sisfb_query_VGA_config_space;
  3380. sishw_ext.pQueryNorthBridgeSpace = &sisfb_query_north_bridge_space;
  3381. strcpy(sishw_ext.szVBIOSVer, "0.84");
  3383. /* TW: Mode numbers for 1280x960 are different for 300 and 310/325 series */
  3384. if(sisvga_engine == SIS_300_VGA) {
  3385. sisbios_mode[MODEINDEX_1280x960].mode_no = 0x6e;
  3386. sisbios_mode[MODEINDEX_1280x960+1].mode_no = 0x6f;
  3387. sisbios_mode[MODEINDEX_1280x960+2].mode_no = 0x7b;
  3388. sisbios_mode[MODEINDEX_1280x960+3].mode_no = 0x7b;
  3389. }
  3391. sishw_ext.pSR = vmalloc(sizeof(SIS_DSReg) * SR_BUFFER_SIZE);
  3392. if (sishw_ext.pSR == NULL) {
  3393. printk(KERN_ERR "sisfb: Fatal error: Allocating SRReg space failed.n");
  3394. return -ENODEV;
  3395. }
  3396. sishw_ext.pSR[0].jIdx = sishw_ext.pSR[0].jVal = 0xFF;
  3398. sishw_ext.pCR = vmalloc(sizeof(SIS_DSReg) * CR_BUFFER_SIZE);
  3399. if (sishw_ext.pCR == NULL) {
  3400.         vfree(sishw_ext.pSR);
  3401. printk(KERN_ERR "sisfb: Fatal error: Allocating CRReg space failed.n");
  3402. return -ENODEV;
  3403. }
  3404. sishw_ext.pCR[0].jIdx = sishw_ext.pCR[0].jVal = 0xFF;
  3406. #ifdef CONFIG_FB_SIS_300
  3407. if(sisvga_engine == SIS_300_VGA) {
  3408. if(!sisvga_enabled) {
  3409. sishw_ext.pjVideoMemoryAddress
  3410. = ioremap(ivideo.video_base, 0x2000000);
  3411. if ((sisbios_mode[sisfb_mode_idx].mode_no) != 0xFF) {   /* TW: for mode "none" */
  3412.         /* TW: SiSInit now for LinuxBIOS only */
  3413. /* SiSInit(&SiS_Pr, &sishw_ext);  */
  3414. outSISIDXREG(SISSR, IND_SIS_PASSWORD, SIS_PASSWORD);
  3415. }
  3416. }
  3417. #ifdef LINUXBIOS
  3418. else {
  3419. sishw_ext.pjVideoMemoryAddress
  3420. = ioremap(ivideo.video_base, 0x2000000);
  3421. if ((sisbios_mode[sisfb_mode_idx].mode_no) != 0xFF) {   /* TW: for mode "none" */
  3422. SiSInit(&SiS_Pr, &sishw_ext);
  3423. outSISIDXREG(SISSR, IND_SIS_PASSWORD, SIS_PASSWORD);
  3424. }
  3425. }
  3426. if((sisbios_mode[sisfb_mode_idx].mode_no) != 0xFF) {   /* TW: for mode "none" */
  3427.         orSISIDXREG(SISSR, 0x07, 0x10);
  3428. }
  3429. #endif
  3430. if(sisfb_get_dram_size_300()) {
  3431.         vfree(sishw_ext.pSR);
  3432. vfree(sishw_ext.pCR);
  3433. printk(KERN_ERR "sisfb: Fatal error: Unable to determine RAM sizen");
  3434. return -ENODEV;
  3435. }
  3436. }
  3437. #endif
  3439. #ifdef CONFIG_FB_SIS_315
  3440. if (sisvga_engine == SIS_315_VGA) {
  3441. if (!sisvga_enabled) {
  3442. /* Mapping Max FB Size for 315 Init */
  3443. // Eden Chen
  3444. //sishw_ext.VirtualVideoMemoryAddress 
  3445. sishw_ext.pjVideoMemoryAddress 
  3446. = ioremap(ivideo.video_base, 0x8000000);
  3447. if ((sisbios_mode[sisfb_mode_idx].mode_no) != 0xFF) {   /* TW: for mode "none" */
  3448.         /* TW: SISInit is now for LINUXBIOS only */
  3449. /* SiSInit(&SiS_Pr, &sishw_ext); */
  3451. outSISIDXREG(SISSR, IND_SIS_PASSWORD, SIS_PASSWORD);
  3453. sishw_ext.bSkipDramSizing = TRUE;
  3454. sishw_ext.pSR[0].jIdx = 0x13;
  3455. sishw_ext.pSR[1].jIdx = 0x14;
  3456. sishw_ext.pSR[2].jIdx = 0xFF;
  3457. inSISIDXREG(SISSR, 0x13, sishw_ext.pSR[0].jVal);
  3458. inSISIDXREG(SISSR, 0x14, sishw_ext.pSR[1].jVal);
  3459. sishw_ext.pSR[2].jVal = 0xFF;
  3460. }
  3461. }
  3462. #ifdef LINUXBIOS
  3463. else {
  3464. sishw_ext.pjVideoMemoryAddress
  3465. = ioremap(ivideo.video_base, 0x8000000);
  3466. if ((sisbios_mode[sisfb_mode_idx].mode_no) != 0xFF) {   /* TW: for mode "none" */
  3468. SiSInit(&SiS_Pr, &sishw_ext);
  3470. outSISIDXREG(SISSR, IND_SIS_PASSWORD, SIS_PASSWORD);
  3472. sishw_ext.bSkipDramSizing = TRUE;
  3473. sishw_ext.pSR[0].jIdx = 0x13;
  3474. sishw_ext.pSR[1].jIdx = 0x14;
  3475. sishw_ext.pSR[2].jIdx = 0xFF;
  3476. inSISIDXREG(SISSR, 0x13, sishw_ext.pSR[0].jVal);
  3477. inSISIDXREG(SISSR, 0x14, sishw_ext.pSR[1].jVal);
  3478. sishw_ext.pSR[2].jVal = 0xFF;
  3479. }
  3480. }
  3481. #endif
  3482. if (sisfb_get_dram_size_315()) {
  3483. vfree(sishw_ext.pSR);
  3484. vfree(sishw_ext.pCR);
  3485. printk(KERN_INFO "sisfb: Fatal error: Unable to determine RAM size.n");
  3486. return -ENODEV;
  3487. }
  3488. }
  3489. #endif
  3491. if ((sisbios_mode[sisfb_mode_idx].mode_no) != 0xFF) {   /* TW: for mode "none" */
  3493.         /* Enable PCI_LINEAR_ADDRESSING and MMIO_ENABLE  */
  3494.         orSISIDXREG(SISSR, IND_SIS_PCI_ADDRESS_SET, (SIS_PCI_ADDR_ENABLE | SIS_MEM_MAP_IO_ENABLE));
  3496.                 /* Enable 2D accelerator engine */
  3497.         orSISIDXREG(SISSR, IND_SIS_MODULE_ENABLE, SIS_ENABLE_2D);
  3499. }
  3501. sishw_ext.ulVideoMemorySize = ivideo.video_size;
  3503. if(sisfb_pdc) {
  3504.     sishw_ext.pdc = sisfb_pdc;
  3505. } else {
  3506.     sishw_ext.pdc = 0;
  3507. }
  3509. if (!request_mem_region(ivideo.video_base, ivideo.video_size, "sisfb FB")) {
  3510. printk(KERN_ERR "sisfb: Fatal error: Unable to reserve frame buffer memoryn");
  3511. printk(KERN_ERR "sisfb: Is there another framebuffer driver active?n");
  3512. vfree(sishw_ext.pSR);
  3513. vfree(sishw_ext.pCR);
  3514. return -ENODEV;
  3515. }
  3517. if (!request_mem_region(ivideo.mmio_base, sisfb_mmio_size, "sisfb MMIO")) {
  3518. printk(KERN_ERR "sisfb: Fatal error: Unable to reserve MMIO regionn");
  3519. release_mem_region(ivideo.video_base, ivideo.video_size);
  3520. vfree(sishw_ext.pSR);
  3521. vfree(sishw_ext.pCR);
  3522. return -ENODEV;
  3523. }
  3525. sishw_ext.pjVideoMemoryAddress = ivideo.video_vbase
  3526. = ioremap(ivideo.video_base, ivideo.video_size);
  3527. ivideo.mmio_vbase = ioremap(ivideo.mmio_base, sisfb_mmio_size);
  3529. printk(KERN_INFO "sisfb: Framebuffer at 0x%lx, mapped to 0x%p, size %dkn",
  3530.        ivideo.video_base, ivideo.video_vbase,
  3531.        ivideo.video_size / 1024);
  3533. printk(KERN_INFO "sisfb: MMIO at 0x%lx, mapped to 0x%p, size %ldkn",
  3534.        ivideo.mmio_base, ivideo.mmio_vbase,
  3535.        sisfb_mmio_size / 1024);
  3537. if(sisfb_heap_init()) {
  3538. printk(KERN_WARNING "sisfb: Failed to initialize offscreen memory heapn");
  3539. }
  3541. ivideo.mtrr = (unsigned int) 0;
  3543. if ((sisbios_mode[sisfb_mode_idx].mode_no) != 0xFF) {   /* TW: for mode "none" */
  3545. #ifdef CONFIG_FB_SIS_300
  3546. if (sisvga_engine == SIS_300_VGA) {
  3547. sisfb_get_VB_type_300();
  3548. }
  3549. #endif
  3551. #ifdef CONFIG_FB_SIS_315
  3552. if (sisvga_engine == SIS_315_VGA) {
  3553. sisfb_get_VB_type_315();
  3554. }
  3555. #endif
  3557. sishw_ext.ujVBChipID = VB_CHIP_UNKNOWN;
  3558. sishw_ext.usExternalChip = 0;
  3560. switch (ivideo.hasVB) {
  3562. case HASVB_301:
  3563.         inSISIDXREG(SISPART4, 0x01, reg);
  3564. if (reg >= 0xE0) {
  3565. sishw_ext.ujVBChipID = VB_CHIP_301LVX;
  3566. printk(KERN_INFO "sisfb: SiS301LVX bridge detected (revision 0x%02x)n",reg);
  3567.    } else if (reg >= 0xD0) {
  3568. sishw_ext.ujVBChipID = VB_CHIP_301LV;
  3569. printk(KERN_INFO "sisfb: SiS301LV bridge detected (revision 0x%02x)n",reg);
  3570.    } else if (reg >= 0xB0) {
  3571. sishw_ext.ujVBChipID = VB_CHIP_301B;
  3572. printk(KERN_INFO "sisfb: SiS301B bridge detected (revision 0x%02xn",reg);
  3573. } else {
  3574. sishw_ext.ujVBChipID = VB_CHIP_301;
  3575. printk(KERN_INFO "sisfb: SiS301 bridge detectedn");
  3576. }
  3577. break;
  3578. case HASVB_302:
  3579.         inSISIDXREG(SISPART4, 0x01, reg);
  3580. if (reg >= 0xE0) {
  3581. sishw_ext.ujVBChipID = VB_CHIP_302LVX;
  3582. printk(KERN_INFO "sisfb: SiS302LVX bridge detected (revision 0x%02x)n",reg);
  3583.    } else if (reg >= 0xD0) {
  3584. sishw_ext.ujVBChipID = VB_CHIP_302LV;
  3585. printk(KERN_INFO "sisfb: SiS302LV bridge detected (revision 0x%02x)n",reg);
  3586.    } else if (reg >= 0xB0) {
  3587.         sishw_ext.ujVBChipID = VB_CHIP_302B;
  3588. printk(KERN_INFO "sisfb: SiS302B bridge detected (revision 0x%02x)n",reg);
  3589. } else {
  3590.         sishw_ext.ujVBChipID = VB_CHIP_302;
  3591. printk(KERN_INFO "sisfb: SiS302 bridge detectedn");
  3592. }
  3593. break;
  3594. case HASVB_303:
  3595. sishw_ext.ujVBChipID = VB_CHIP_303;
  3596. printk(KERN_INFO "sisfb: SiS303 bridge detected (not supported)n");
  3597. break;
  3598. case HASVB_LVDS:
  3599. sishw_ext.usExternalChip = 0x1;
  3600. printk(KERN_INFO "sisfb: LVDS transmitter detectedn");
  3601. break;
  3602. case HASVB_TRUMPION:
  3603. sishw_ext.usExternalChip = 0x2;
  3604. printk(KERN_INFO "sisfb: Trumpion Zurac LVDS scaler detectedn");
  3605. break;
  3606. case HASVB_CHRONTEL:
  3607. sishw_ext.usExternalChip = 0x4;
  3608. printk(KERN_INFO "sisfb: Chrontel TV encoder detectedn");
  3609. break;
  3610. case HASVB_LVDS_CHRONTEL:
  3611. sishw_ext.usExternalChip = 0x5;
  3612. printk(KERN_INFO "sisfb: LVDS transmitter and Chrontel TV encoder detectedn");
  3613. break;
  3614. default:
  3615. printk(KERN_INFO "sisfb: No or unknown bridge type detectedn");
  3616. break;
  3617. }
  3619. if (ivideo.hasVB != HASVB_NONE) {
  3620. #ifdef CONFIG_FB_SIS_300
  3621.       if (sisvga_engine == SIS_300_VGA) {
  3622. sisfb_detect_VB_connect_300();
  3623.                       }
  3624. #endif
  3625. #ifdef CONFIG_FB_SIS_315
  3626.       if (sisvga_engine == SIS_315_VGA) {
  3627. sisfb_detect_VB_connect_315();
  3628.                       }
  3629. #endif
  3630. }
  3632. if (ivideo.disp_state & DISPTYPE_DISP2) {
  3633. if (sisfb_crt1off)
  3634. ivideo.disp_state |= DISPMODE_SINGLE;
  3635. else
  3636. ivideo.disp_state |= (DISPMODE_MIRROR | DISPTYPE_CRT1);
  3637. } else {
  3638. ivideo.disp_state = DISPMODE_SINGLE | DISPTYPE_CRT1;
  3639. }
  3641. if (ivideo.disp_state & DISPTYPE_LCD) {
  3642.     if (!enable_dstn) {
  3643.         inSISIDXREG(SISCR, IND_SIS_LCD_PANEL, reg);
  3644. reg &= 0x0f;
  3645. if (sisvga_engine == SIS_300_VGA) {
  3646.     sishw_ext.ulCRT2LCDType = sis300paneltype[reg];
  3647. } else {
  3648.     sishw_ext.ulCRT2LCDType = sis310paneltype[reg];
  3649. }
  3650.     } else {
  3651.         /* TW: FSTN/DSTN */
  3652. sishw_ext.ulCRT2LCDType = LCD_320x480;
  3653.     }
  3654. }
  3656. if (sisfb_mode_idx >= 0)
  3657. sisfb_mode_idx = sisfb_validate_mode(sisfb_mode_idx);
  3659. if (sisfb_mode_idx < 0) {
  3660. switch (ivideo.disp_state & DISPTYPE_DISP2) {
  3661.    case DISPTYPE_LCD:
  3662. sisfb_mode_idx = DEFAULT_LCDMODE;
  3663. break;
  3664.    case DISPTYPE_TV:
  3665. sisfb_mode_idx = DEFAULT_TVMODE;
  3666. break;
  3667.    default:
  3668. sisfb_mode_idx = DEFAULT_MODE;
  3669. break;
  3670. }
  3671. }
  3673. sisfb_mode_no = sisbios_mode[sisfb_mode_idx].mode_no;
  3675. if (ivideo.refresh_rate != 0)
  3676. sisfb_search_refresh_rate(ivideo.refresh_rate);
  3678. if (sisfb_rate_idx == 0) {
  3679. sisfb_rate_idx = sisbios_mode[sisfb_mode_idx].rate_idx;
  3680. ivideo.refresh_rate = 60;
  3681. }
  3683. ivideo.video_bpp = sisbios_mode[sisfb_mode_idx].bpp;
  3684. ivideo.video_vwidth = ivideo.video_width = sisbios_mode[sisfb_mode_idx].xres;
  3685. ivideo.video_vheight = ivideo.video_height = sisbios_mode[sisfb_mode_idx].yres;
  3686. ivideo.org_x = ivideo.org_y = 0;
  3687. ivideo.video_linelength = ivideo.video_width * (ivideo.video_bpp >> 3);
  3688. switch(ivideo.video_bpp) {
  3689.          case 8:
  3690.              ivideo.DstColor = 0x0000;
  3691.      ivideo.SiS310_AccelDepth = 0x00000000;
  3692. ivideo.video_cmap_len = 256;
  3693.              break;
  3694.          case 16:
  3695.              ivideo.DstColor = 0x8000;
  3696.              ivideo.SiS310_AccelDepth = 0x00010000;
  3697. ivideo.video_cmap_len = 16;
  3698.              break;
  3699.          case 32:
  3700.              ivideo.DstColor = 0xC000;
  3701.      ivideo.SiS310_AccelDepth = 0x00020000;
  3702. ivideo.video_cmap_len = 16;
  3703.              break;
  3704. default:
  3705. ivideo.video_cmap_len = 16;
  3706.         printk(KERN_INFO "sisfb: Unsupported accel depth %d", ivideo.video_bpp);
  3707. sisfb_accel = 0;
  3708. break;
  3709.      }
  3711. printk(KERN_INFO "sisfb: Mode is %dx%dx%d (%dHz)n",
  3712.         ivideo.video_width, ivideo.video_height, ivideo.video_bpp,
  3713. ivideo.refresh_rate);
  3715. sisfb_pre_setmode();
  3717. if (SiSSetMode(&SiS_Pr, &sishw_ext, sisfb_mode_no) == 0) {
  3718. printk("sisfb: Setting mode[0x%x] failed, using default moden", sisfb_mode_no);
  3719. return -1;
  3720. }
  3722. outSISIDXREG(SISSR, IND_SIS_PASSWORD, SIS_PASSWORD);
  3724. sisfb_post_setmode();
  3726. sisfb_crtc_to_var(&default_var);
  3728. if(sisfb_accel) {
  3729.    sisfb_initaccel();
  3730. }
  3732. #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,5,33) /* ---- 2.4 series init ---- */
  3733. #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,23)
  3734. sis_fb_info.screen_base = ivideo.video_vbase;
  3735. sis_fb_info.currcon = -1;
  3736. #endif
  3737. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
  3738. sis_fb_info.node = -1;
  3739. #else
  3740. sis_fb_info.node = NODEV;
  3741. #endif
  3742. #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,5,23)
  3743. sis_fb_info.blank = &sisfb_blank;
  3744. #endif
  3745. sis_fb_info.fbops = &sisfb_ops;
  3746. sis_fb_info.switch_con = &sisfb_switch;
  3747. sis_fb_info.updatevar = &sisfb_update_var;
  3748. sis_fb_info.changevar = NULL;
  3749. sis_fb_info.disp = &sis_disp;
  3750. sis_fb_info.flags = FBINFO_FLAG_DEFAULT;
  3752. sisfb_set_disp(-1, &default_var, &sis_fb_info);
  3753. #endif
  3755. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,34) /* ---- 2.5 series init ---- */
  3756. sis_fb_info.screen_base = ivideo.video_vbase;
  3757. sis_fb_info.node = NODEV;
  3758. sis_fb_info.fbops = &sisfb_ops;
  3759. sisfb_get_fix(&sis_fb_info.fix, -1, &sis_fb_info);
  3760. sis_fb_info.pseudo_palette = pseudo_palette;
  3761. sis_fb_info.flags = FBINFO_FLAG_DEFAULT;
  3763. sis_fb_info.changevar = NULL;
  3764. sis_fb_info.currcon = -1;
  3765. sis_fb_info.disp = &sis_disp;
  3766. sis_fb_info.switch_con = gen_switch;
  3767. sis_fb_info.updatevar = gen_update_var;
  3769. fb_alloc_cmap(&sis_fb_info.cmap, 256, 0);
  3771. sis_fb_info.var = default_var;
  3772. #endif
  3774. #ifdef CONFIG_MTRR
  3775. ivideo.mtrr = mtrr_add((unsigned int) ivideo.video_base,
  3776. (unsigned int) ivideo.video_size,
  3777. MTRR_TYPE_WRCOMB, 1);
  3778. if(ivideo.mtrr) {
  3779. printk(KERN_INFO "sisfb: Added MTRRsn");
  3780. }
  3781. #endif
  3783. #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,5,33)
  3784. vc_resize_con(1, 1, 0);
  3785. #endif
  3786. TWDEBUG("Before calling register_framebuffer");
  3787. if(register_framebuffer(&sis_fb_info) < 0)
  3788. return -EINVAL;
  3790. printk(KERN_INFO "sisfb: Installed SISFB_GET_INFO ioctl (%x)n", SISFB_GET_INFO);
  3792. #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,5,33)
  3793. printk(KERN_INFO "sisfb: 2D acceleration is %s, scrolling mode %sn",
  3794.      sisfb_accel ? "enabled" : "disabled",
  3795.      sisfb_ypan  ? "ypan" : "redraw");
  3796. #endif
  3797. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,34)
  3798. printk(KERN_INFO "sisfb: 2D acceleration is %sn",
  3799.      sisfb_accel ? "enabled" : "disabled");
  3800. #endif
  3802. printk(KERN_INFO "fb%d: %s frame buffer device, Version %d.%d.%02dn",
  3803.         GET_FB_IDX(sis_fb_info.node), sis_fb_info.modename, VER_MAJOR, VER_MINOR,
  3804.         VER_LEVEL);
  3807. } /* TW: if mode = "none" */
  3808. return 0;
  3809. }
  3811. /* ------------------------------------------------------------------------------ */
  3813. /* TW: As long as the generic framebuffer parts don't work as modules, we use
  3814.    our own stuff here. I can't debug a fb driver if I need to compile the driver
  3815.    into the kernel. It simply drives me nuts.
  3816.  */
  3817. #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,33)
  3819. #include <linux/version.h>
  3820. #include <linux/string.h>
  3821. #include <linux/fb.h>
  3822. #include <asm/types.h>
  3824. #include <video/fbcon.h>
  3826. void my_cfb_imageblit(struct fb_info *p, struct fb_image *image)
  3827. {
  3828. int pad, ppw;
  3829. int x2, y2, n, i, j, k, l = 7;
  3830. unsigned long tmp = ~0 << (BITS_PER_LONG - p->var.bits_per_pixel);
  3831. unsigned long fgx, bgx, fgcolor, bgcolor, eorx;
  3832. unsigned long end_mask;
  3833. unsigned long *dst = NULL;
  3834. u8 *dst1;
  3835. u8 *src;
  3837. /*
  3838.  * We could use hardware clipping but on many cards you get around hardware
  3839.  * clipping by writing to framebuffer directly like we are doing here.
  3840.  */
  3841. x2 = image->dx + image->width;
  3842. y2 = image->dy + image->height;
  3843. image->dx = image->dx > 0 ? image->dx : 0;
  3844. image->dy = image->dy > 0 ? image->dy : 0;
  3845. x2 = x2 < p->var.xres_virtual ? x2 : p->var.xres_virtual;
  3846. y2 = y2 < p->var.yres_virtual ? y2 : p->var.yres_virtual;
  3847. image->width  = x2 - image->dx;
  3848. image->height = y2 - image->dy;
  3850. dst1 = p->screen_base + image->dy * p->fix.line_length +
  3851. ((image->dx * p->var.bits_per_pixel) >> 3);
  3853. ppw = BITS_PER_LONG/p->var.bits_per_pixel;
  3855. src = image->data;
  3857. if (image->depth == 1) {
  3859. if (p->fix.visual == FB_VISUAL_TRUECOLOR) {
  3860. fgx = fgcolor = ((u32 *)(p->pseudo_palette))[image->fg_color];
  3861. bgx = bgcolor = ((u32 *)(p->pseudo_palette))[image->bg_color];
  3862. } else {
  3863. fgx = fgcolor = image->fg_color;
  3864. bgx = bgcolor = image->bg_color;
  3865. }
  3867. for (i = 0; i < ppw-1; i++) {
  3868. fgx <<= p->var.bits_per_pixel;
  3869. bgx <<= p->var.bits_per_pixel;
  3870. fgx |= fgcolor;
  3871. bgx |= bgcolor;
  3872. }
  3873. eorx = fgx ^ bgx;
  3874. n = ((image->width + 7) >> 3);
  3875. pad = (n << 3) - image->width;
  3876. n = image->width % ppw;
  3878. for (i = 0; i < image->height; i++) {
  3879. dst = (unsigned long *) dst1;
  3881. for (j = image->width/ppw; j > 0; j--) {
  3882. end_mask = 0;
  3884. for (k = ppw; k > 0; k--) {
  3885. if (test_bit(l, (unsigned long *) src))
  3886. end_mask |= (tmp >> (p->var.bits_per_pixel*(k-1)));
  3887. l--;
  3888. if (l < 0) { l = 7; src++; }
  3889. }
  3890. fb_writel((end_mask & eorx)^bgx, dst);
  3891. dst++;
  3892. }
  3894. if (n) {
  3895. end_mask = 0;
  3896. for (j = n; j > 0; j--) {
  3897. if (test_bit(l, (unsigned long *) src))
  3898. end_mask |= (tmp >> (p->var.bits_per_pixel*(j-1)));
  3899. l--;
  3900. if (l < 0) { l = 7; src++; }
  3901. }
  3902. fb_writel((end_mask & eorx)^bgx, dst);
  3903. dst++;
  3904. }
  3905. l -= pad;
  3906. dst1 += p->fix.line_length;
  3907. }
  3908. } else {
  3909. /* Draw the penguin */
  3910. n = ((image->width * p->var.bits_per_pixel) >> 3);
  3911. end_mask = 0;
  3912. }
  3913. }
  3914. #endif
  3915. /* -------------------------------------------------------------------------------- */
  3918. #ifdef MODULE
  3920. static char         *mode = NULL;
  3921. static int          vesa = -1;
  3922. static unsigned int rate = 0;
  3923. static unsigned int crt1off = 1;
  3924. static unsigned int mem = 0;
  3925. static unsigned int dstn = 0;
  3926. static char         *forcecrt2type = NULL;
  3927. static int          forcecrt1 = -1;
  3928. static char         *queuemode = NULL;
  3929. static int          pdc = 0;
  3930. static int          noaccel = -1;
  3931. static int          noypan  = -1;
  3932. static int          inverse = 0;
  3934. MODULE_DESCRIPTION("SiS 300/540/630/730/315/550/650/740 framebuffer driver");
  3935. MODULE_LICENSE("GPL");
  3936. MODULE_AUTHOR("Various; SiS; Thomas Winischhofer <thomas@winischhofer.net>");
  3938. MODULE_PARM(mode, "s");
  3939. MODULE_PARM_DESC(mode,
  3940.        "nSelects the desired display mode in the format [X]x[Y]x[Depth], eg.n"
  3941.          "800x600x16 (default: none if sisfb is a module; this leaves then"
  3942.  "console untouched and the driver will only do the video memoryn"
  3943.  "management for eg. DRM/DRI; 800x600x8 if sisfb is in the kernel)");
  3945. MODULE_PARM(vesa, "i");
  3946. MODULE_PARM_DESC(vesa,
  3947.        "nSelects the desired display mode by VESA defined mode number, eg. 0x117n"
  3948.          "(default: 0x0000 if sisfb is a module; this leaves the console untouchedn"
  3949.  "and the driver will only do the video memory management for eg. DRM/DRI;n"
  3950.  "0x0103 if sisfb is in the kernel)");
  3952. MODULE_PARM(rate, "i");
  3953. MODULE_PARM_DESC(rate,
  3954. "nSelects the desired vertical refresh rate for CRT1 (external VGA) in Hz.n"
  3955. "(default: 60)");
  3957. MODULE_PARM(crt1off,   "i");
  3958. MODULE_PARM_DESC(crt1off,
  3959. "(Deprecated, please use forcecrt1)");
  3961. MODULE_PARM(filter, "i");
  3962. MODULE_PARM_DESC(filter,
  3963. "nSelects TV flicker filter type (only for systems with a SiS301 video bridge).n"
  3964.   "(Possible values 0-7, default: [no filter])");
  3966. MODULE_PARM(dstn,   "i"); /* JennyLee 20011211 */
  3967. MODULE_PARM_DESC(dstn,
  3968. "nSelects DSTN/FSTN display mode for SiS550. This sets CRT2 type to LCD andn"
  3969.   "overrides forcecrt2type setting. (1=ON, 0=OFF) (default: 0)");
  3971. MODULE_PARM(queuemode,   "s");
  3972. MODULE_PARM_DESC(queuemode,
  3973. "nSelects the queue mode on 315/550/650/740. Possible choices are AGP, VRAM orn"
  3974.      "MMIO. AGP is only available if the kernel has AGP support. The queue mode isn"
  3975.   "important to programs using the 2D/3D accelerator of the SiS chip. The modesn"
  3976.   "require a totally different way of programming the engines. If any mode thann"
  3977.   "MMIO is selected, sisfb will disable its own 2D acceleration. Onn"
  3978.   "300/540/630/730, this option is ignored. (default: MMIO)");
  3980. /* TW: "Import" the options from the X driver */
  3981. MODULE_PARM(mem,    "i");
  3982. MODULE_PARM_DESC(mem,
  3983. "nDetermines the beginning of the video memory heap in KB. This heap is usedn"
  3984.   "for video RAM management for eg. DRM/DRI. The default depends on the amountn"
  3985.   "of video RAM available. If 8MB of video RAM or less is available, the heapn"
  3986.   "starts at 4096KB, if between 8 and 16MB are available at 8192KB, otherwisen"
  3987.   "at 12288KB. The value is to be specified without 'KB' and should matchn"
  3988.   "the MaxXFBMem setting for XFree 4.x (x>=2).");
  3990. MODULE_PARM(forcecrt2type, "s");
  3991. MODULE_PARM_DESC(forcecrt2type,
  3992. "nIf this option is omitted, the driver autodetects CRT2 output devices, such asn"
  3993.   "LCD, TV or secondary VGA. With this option, this autodetection can ben"
  3994.   "overridden. Possible parameters are LCD, TV, VGA or NONE. NONE disables CRT2.n"
  3995.   "On systems with a 301(B) bridge, parameters SVIDEO, COMPOSITE or SCART can ben"
  3996.   "used instead of TV to override the TV detection. (default: [autodetected])");
  3998. MODULE_PARM(forcecrt1, "i");
  3999. MODULE_PARM_DESC(forcecrt1,
  4000. "nNormally, the driver autodetects whether or not CRT1 (external VGA) is n"
  4001.   "connected. With this option, the detection can be overridden (1=CRT1 ON,n"
  4002.   " 0=CRT1 off) (default: [autodetected])");
  4004. MODULE_PARM(pdc, "i");
  4005. MODULE_PARM_DESC(pdc,
  4006.         "n(300 series only) This is for manually selecting the LCD panel delayn"
  4007.   "compensation. The driver should detect this correctly in most cases; however,n"
  4008.   "sometimes this is not possible. If you see 'small waves' on the LCD, tryn"
  4009.   "setting this to 4, 32 or 24. If the problem persists, try other valuesn"
  4010.   "between 4 and 60 in steps of 4. (default: [autodetected])");
  4012. MODULE_PARM(noaccel, "i");
  4013. MODULE_PARM_DESC(noaccel,
  4014.         "nIf set to anything other than 0, 2D acceleration and y-panning will ben"
  4015. "disabled. (default: 0)");
  4017. MODULE_PARM(noypan, "i");
  4018. MODULE_PARM_DESC(noypan,
  4019.         "nIf set to anything other than 0, y-panning will be disabled and scrollingn"
  4020. "will be performed by redrawing the screen. This required 2D acceleration, son"
  4021. "if the option noaccel is set, y-panning will be disabled. (default: 0)");
  4023. MODULE_PARM(inverse, "i");
  4024. MODULE_PARM_DESC(inverse,
  4025.         "nSetting this to anything but 0 should invert the display colors, but thisn"
  4026. "does not seem to work. (default: 0)");
  4028. int init_module(void)
  4029. {
  4030. if(mode)
  4031. sisfb_search_mode(mode);
  4032. else if(vesa != -1)
  4033. sisfb_search_vesamode(vesa);
  4034. else  /* TW: set mode=none if no mode is given - we do this only if we are a module */
  4035. sisfb_mode_idx = MODE_INDEX_NONE;
  4037. ivideo.refresh_rate = rate;
  4039. if(forcecrt2type)
  4040. sisfb_search_crt2type(forcecrt2type);
  4042. if(crt1off == 0)
  4043. sisfb_crt1off = 1;
  4044. else
  4045. sisfb_crt1off = 0;
  4047. sisfb_forcecrt1 = forcecrt1;
  4048. if(forcecrt1 == 1)
  4049. sisfb_crt1off = 0;
  4050. else if(forcecrt1 == 0)
  4051. sisfb_crt1off = 1;
  4053. if(noaccel == 1)      sisfb_accel = 0;
  4054. else if(noaccel == 0) sisfb_accel = 1;
  4056. if(noypan == 1)       sisfb_ypan = 0;
  4057. else if(noypan == 0)  sisfb_ypan = 1;
  4059. /* TW: Panning only with acceleration */
  4060. if(sisfb_accel == 0)  sisfb_ypan = 0;
  4062. if(inverse)           sisfb_inverse = 1;
  4064. if(mem)       sisfb_mem = mem;
  4066. enable_dstn = dstn;
  4068. /* TW: DSTN overrules forcecrt2type */
  4069. if (enable_dstn)      sisfb_crt2type = DISPTYPE_LCD;
  4071. if (queuemode)        sisfb_search_queuemode(queuemode);
  4072. /* TW: If other queuemode than MMIO, disable 2D accel any ypan */
  4073. if((sisfb_queuemode != -1) && (sisfb_queuemode != MMIO_CMD)) {
  4074.         sisfb_accel = 0;
  4075. sisfb_ypan = 0;
  4076. }
  4078.         if(pdc) {
  4079.    if(!(pdc & ~0x3c)) {
  4080.         sisfb_pdc = pdc & 0x3c;
  4081.    }
  4082. }
  4084. if(sisfb_init() < 0) return -ENODEV;
  4086. return 0;
  4087. }
  4089. void cleanup_module(void)
  4090. {
  4091. /* TW: Release mem regions */
  4092. release_mem_region(ivideo.video_base, ivideo.video_size);
  4093. release_mem_region(ivideo.mmio_base, sisfb_mmio_size);
  4094. #ifdef CONFIG_MTRR
  4095. /* TW: Release MTRR region */
  4096. if(ivideo.mtrr) mtrr_del(ivideo.mtrr,
  4097.       (unsigned int)ivideo.video_base,
  4098.                       (unsigned int)ivideo.video_size);
  4099. #endif
  4100. /* Unregister the framebuffer */
  4101. unregister_framebuffer(&sis_fb_info);
  4102. printk(KERN_INFO "sisfb: Module unloadedn");
  4103. }
  4105. #endif
  4107. EXPORT_SYMBOL(sis_malloc);
  4108. EXPORT_SYMBOL(sis_free);
  4109. EXPORT_SYMBOL(sis_dispinfo);
  4111. EXPORT_SYMBOL(ivideo);
  4112.