/drivers/video/sis/init301.c

https://bitbucket.org/abioy/linux · C · 11260 lines · 9172 code · 1583 blank · 505 comment · 3574 complexity · f965b504f6b9a385cf8db7cb0d0906b8 MD5 · raw file

Large files are truncated click here to view the full file

    

  1. /* $XFree86$ */
    2. 

  2. /* $XdotOrg$ */
    3. 

  3. /*
    4. 

  4.  * Mode initializing code (CRT2 section)
    5. 

  5.  * for SiS 300/305/540/630/730,
    6. 

  6.  *     SiS 315/550/[M]650/651/[M]661[FGM]X/[M]74x[GX]/330/[M]76x[GX],
    7. 

  7.  *     XGI V3XT/V5/V8, Z7
    8. 

  8.  * (Universal module for Linux kernel framebuffer and X.org/XFree86 4.x)
    9. 

  9.  *
    10. 

  10.  * Copyright (C) 2001-2005 by Thomas Winischhofer, Vienna, Austria
    11. 

  11.  *
    12. 

  12.  * If distributed as part of the Linux kernel, the following license terms
    13. 

  13.  * apply:
    14. 

  14.  *
    15. 

  15.  * * This program is free software; you can redistribute it and/or modify
    16. 

  16.  * * it under the terms of the GNU General Public License as published by
    17. 

  17.  * * the Free Software Foundation; either version 2 of the named License,
    18. 

  18.  * * or any later version.
    19. 

  19.  * *
    20. 

  20.  * * This program is distributed in the hope that it will be useful,
    21. 

  21.  * * but WITHOUT ANY WARRANTY; without even the implied warranty of
    22. 

  22.  * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    23. 

  23.  * * GNU General Public License for more details.
    24. 

  24.  * *
    25. 

  25.  * * You should have received a copy of the GNU General Public License
    26. 

  26.  * * along with this program; if not, write to the Free Software
    27. 

  27.  * * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA
    28. 

  28.  *
    29. 

  29.  * Otherwise, the following license terms apply:
    30. 

  30.  *
    31. 

  31.  * * Redistribution and use in source and binary forms, with or without
    32. 

  32.  * * modification, are permitted provided that the following conditions
    33. 

  33.  * * are met:
    34. 

  34.  * * 1) Redistributions of source code must retain the above copyright
    35. 

  35.  * *    notice, this list of conditions and the following disclaimer.
    36. 

  36.  * * 2) Redistributions in binary form must reproduce the above copyright
    37. 

  37.  * *    notice, this list of conditions and the following disclaimer in the
    38. 

  38.  * *    documentation and/or other materials provided with the distribution.
    39. 

  39.  * * 3) The name of the author may not be used to endorse or promote products
    40. 

  40.  * *    derived from this software without specific prior written permission.
    41. 

  41.  * *
    42. 

  42.  * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
    43. 

  43.  * * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
    44. 

  44.  * * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
    45. 

  45.  * * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
    46. 

  46.  * * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
    47. 

  47.  * * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
    48. 

  48.  * * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
    49. 

  49.  * * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    50. 

  50.  * * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
    51. 

  51.  * * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    52. 

  52.  *
    53. 

  53.  * Author: 	Thomas Winischhofer <thomas@winischhofer.net>
    54. 

  54.  *
    55. 

  55.  * Formerly based on non-functional code-fragements for 300 series by SiS, Inc.
    56. 

  56.  * Used by permission.
    57. 

  57.  *
    58. 

  58.  */
    59. 

  59. 

  60. #ifdef HAVE_CONFIG_H
    61. 

  61. #include "config.h"
    62. 

  62. #endif
    63. 

  63. 

  64. #if 1
    65. 

  65. #define SET_EMI		/* 302LV/ELV: Set EMI values */
    66. 

  66. #endif
    67. 

  67. 

  68. #if 1
    69. 

  69. #define SET_PWD		/* 301/302LV: Set PWD */
    70. 

  70. #endif
    71. 

  71. 

  72. #define COMPAL_HACK	/* Needed for Compal 1400x1050 (EMI) */
    73. 

  73. #define COMPAQ_HACK	/* Needed for Inventec/Compaq 1280x1024 (EMI) */
    74. 

  74. #define ASUS_HACK	/* Needed for Asus A2H 1024x768 (EMI) */
    75. 

  75. 

  76. #include "init301.h"
    77. 

  77. 

  78. #ifdef SIS300
    79. 

  79. #include "oem300.h"
    80. 

  80. #endif
    81. 

  81. 

  82. #ifdef SIS315H
    83. 

  83. #include "oem310.h"
    84. 

  84. #endif
    85. 

  85. 

  86. #define SiS_I2CDELAY      1000
    87. 

  87. #define SiS_I2CDELAYSHORT  150
    88. 

  88. 

  89. static unsigned short	SiS_GetBIOSLCDResInfo(struct SiS_Private *SiS_Pr);
    90. 

  90. #ifdef SIS_LINUX_KERNEL
    91. 

  91. static void		SiS_SetCH70xx(struct SiS_Private *SiS_Pr, unsigned short reg, unsigned char val);
    92. 

  92. #endif
    93. 

  93. 

  94. /*********************************************/
    95. 

  95. /*         HELPER: Lock/Unlock CRT2          */
    96. 

  96. /*********************************************/
    97. 

  97. 

  98. void
    99. 

  99. SiS_UnLockCRT2(struct SiS_Private *SiS_Pr)
    100. 

  100. {
    101. 

  101.    if(SiS_Pr->ChipType == XGI_20)
    102. 

  102.       return;
    103. 

  103.    else if(SiS_Pr->ChipType >= SIS_315H)
    104. 

  104.       SiS_SetRegOR(SiS_Pr->SiS_Part1Port,0x2f,0x01);
    105. 

  105.    else
    106. 

  106.       SiS_SetRegOR(SiS_Pr->SiS_Part1Port,0x24,0x01);
    107. 

  107. }
    108. 

  108. 

  109. #ifdef SIS_LINUX_KERNEL
    110. 

  110. static
    111. 

  111. #endif
    112. 

  112. void
    113. 

  113. SiS_LockCRT2(struct SiS_Private *SiS_Pr)
    114. 

  114. {
    115. 

  115.    if(SiS_Pr->ChipType == XGI_20)
    116. 

  116.       return;
    117. 

  117.    else if(SiS_Pr->ChipType >= SIS_315H)
    118. 

  118.       SiS_SetRegAND(SiS_Pr->SiS_Part1Port,0x2F,0xFE);
    119. 

  119.    else
    120. 

  120.       SiS_SetRegAND(SiS_Pr->SiS_Part1Port,0x24,0xFE);
    121. 

  121. }
    122. 

  122. 

  123. /*********************************************/
    124. 

  124. /*            HELPER: Write SR11             */
    125. 

  125. /*********************************************/
    126. 

  126. 

  127. static void
    128. 

  128. SiS_SetRegSR11ANDOR(struct SiS_Private *SiS_Pr, unsigned short DataAND, unsigned short DataOR)
    129. 

  129. {
    130. 

  130.    if(SiS_Pr->ChipType >= SIS_661) {
    131. 

  131.       DataAND &= 0x0f;
    132. 

  132.       DataOR  &= 0x0f;
    133. 

  133.    }
    134. 

  134.    SiS_SetRegANDOR(SiS_Pr->SiS_P3c4,0x11,DataAND,DataOR);
    135. 

  135. }
    136. 

  136. 

  137. /*********************************************/
    138. 

  138. /*    HELPER: Get Pointer to LCD structure   */
    139. 

  139. /*********************************************/
    140. 

  140. 

  141. #ifdef SIS315H
    142. 

  142. static unsigned char *
    143. 

  143. GetLCDStructPtr661(struct SiS_Private *SiS_Pr)
    144. 

  144. {
    145. 

  145.    unsigned char  *ROMAddr = SiS_Pr->VirtualRomBase;
    146. 

  146.    unsigned char  *myptr = NULL;
    147. 

  147.    unsigned short romindex = 0, reg = 0, idx = 0;
    148. 

  148. 

  149.    /* Use the BIOS tables only for LVDS panels; TMDS is unreliable
    150. 

  150.     * due to the variaty of panels the BIOS doesn't know about.
    151. 

  151.     * Exception: If the BIOS has better knowledge (such as in case
    152. 

  152.     * of machines with a 301C and a panel that does not support DDC)
    153. 

  153.     * use the BIOS data as well.
    154. 

  154.     */
    155. 

  155. 

  156.    if((SiS_Pr->SiS_ROMNew) &&
    157. 

  157.       ((SiS_Pr->SiS_VBType & VB_SISLVDS) || (!SiS_Pr->PanelSelfDetected))) {
    158. 

  158. 

  159.       if(SiS_Pr->ChipType < SIS_661) reg = 0x3c;
    160. 

  160.       else                           reg = 0x7d;
    161. 

  161. 

  162.       idx = (SiS_GetReg(SiS_Pr->SiS_P3d4,reg) & 0x1f) * 26;
    163. 

  163. 

  164.       if(idx < (8*26)) {
    165. 

  165.          myptr = (unsigned char *)&SiS_LCDStruct661[idx];
    166. 

  166.       }
    167. 

  167.       romindex = SISGETROMW(0x100);
    168. 

  168.       if(romindex) {
    169. 

  169.          romindex += idx;
    170. 

  170.          myptr = &ROMAddr[romindex];
    171. 

  171.       }
    172. 

  172.    }
    173. 

  173.    return myptr;
    174. 

  174. }
    175. 

  175. 

  176. static unsigned short
    177. 

  177. GetLCDStructPtr661_2(struct SiS_Private *SiS_Pr)
    178. 

  178. {
    179. 

  179.    unsigned char  *ROMAddr = SiS_Pr->VirtualRomBase;
    180. 

  180.    unsigned short romptr = 0;
    181. 

  181. 

  182.    /* Use the BIOS tables only for LVDS panels; TMDS is unreliable
    183. 

  183.     * due to the variaty of panels the BIOS doesn't know about.
    184. 

  184.     * Exception: If the BIOS has better knowledge (such as in case
    185. 

  185.     * of machines with a 301C and a panel that does not support DDC)
    186. 

  186.     * use the BIOS data as well.
    187. 

  187.     */
    188. 

  188. 

  189.    if((SiS_Pr->SiS_ROMNew) &&
    190. 

  190.       ((SiS_Pr->SiS_VBType & VB_SISLVDS) || (!SiS_Pr->PanelSelfDetected))) {
    191. 

  191.       romptr = SISGETROMW(0x102);
    192. 

  192.       romptr += ((SiS_GetReg(SiS_Pr->SiS_P3d4,0x36) >> 4) * SiS_Pr->SiS661LCD2TableSize);
    193. 

  193.    }
    194. 

  194. 

  195.    return romptr;
    196. 

  196. }
    197. 

  197. #endif
    198. 

  198. 

  199. /*********************************************/
    200. 

  200. /*           Adjust Rate for CRT2            */
    201. 

  201. /*********************************************/
    202. 

  202. 

  203. static bool
    204. 

  204. SiS_AdjustCRT2Rate(struct SiS_Private *SiS_Pr, unsigned short ModeNo, unsigned short ModeIdIndex,
    205. 

  205. 		unsigned short RRTI, unsigned short *i)
    206. 

  206. {
    207. 

  207.    unsigned short checkmask=0, modeid, infoflag;
    208. 

  208. 

  209.    modeid = SiS_Pr->SiS_RefIndex[RRTI + (*i)].ModeID;
    210. 

  210. 

  211.    if(SiS_Pr->SiS_VBType & VB_SISVB) {
    212. 

  212. 

  213.       if(SiS_Pr->SiS_VBInfo & SetCRT2ToRAMDAC) {
    214. 

  214. 

  215. 	 checkmask |= SupportRAMDAC2;
    216. 

  216. 	 if(SiS_Pr->ChipType >= SIS_315H) {
    217. 

  217. 	    checkmask |= SupportRAMDAC2_135;
    218. 

  218. 	    if(SiS_Pr->SiS_VBType & VB_SIS30xBLV) {
    219. 

  219. 	       checkmask |= SupportRAMDAC2_162;
    220. 

  220. 	       if(SiS_Pr->SiS_VBType & VB_SISRAMDAC202) {
    221. 

  221. 		  checkmask |= SupportRAMDAC2_202;
    222. 

  222. 	       }
    223. 

  223. 	    }
    224. 

  224. 	 }
    225. 

  225. 

  226.       } else if(SiS_Pr->SiS_VBInfo & (SetCRT2ToLCD | SetCRT2ToLCDA)) {
    227. 

  227. 

  228. 	 checkmask |= SupportLCD;
    229. 

  229. 	 if(SiS_Pr->ChipType >= SIS_315H) {
    230. 

  230. 	    if(SiS_Pr->SiS_VBType & VB_SISVB) {
    231. 

  231. 	       if((SiS_Pr->SiS_LCDInfo & DontExpandLCD) && (SiS_Pr->SiS_LCDInfo & LCDPass11)) {
    232. 

  232. 	          if(modeid == 0x2e) checkmask |= Support64048060Hz;
    233. 

  233. 	       }
    234. 

  234. 	    }
    235. 

  235. 	 }
    236. 

  236. 

  237.       } else if(SiS_Pr->SiS_VBInfo & SetCRT2ToHiVision) {
    238. 

  238. 

  239. 	 checkmask |= SupportHiVision;
    240. 

  240. 

  241.       } else if(SiS_Pr->SiS_VBInfo & (SetCRT2ToYPbPr525750|SetCRT2ToAVIDEO|SetCRT2ToSVIDEO|SetCRT2ToSCART)) {
    242. 

  242. 

  243. 	 checkmask |= SupportTV;
    244. 

  244. 	 if(SiS_Pr->SiS_VBType & VB_SIS30xBLV) {
    245. 

  245. 	    checkmask |= SupportTV1024;
    246. 

  246. 	    if(SiS_Pr->SiS_VBInfo & SetCRT2ToYPbPr525750) {
    247. 

  247. 	       if(SiS_Pr->SiS_TVMode & TVSetYPbPr750p) {
    248. 

  248. 	          checkmask |= SupportYPbPr750p;
    249. 

  249. 	       }
    250. 

  250. 	    }
    251. 

  251. 	 }
    252. 

  252. 

  253.       }
    254. 

  254. 

  255.    } else {	/* LVDS */
    256. 

  256. 

  257.       if(SiS_Pr->SiS_IF_DEF_CH70xx != 0) {
    258. 

  258. 	 if(SiS_Pr->SiS_VBInfo & SetCRT2ToTV) {
    259. 

  259. 	    checkmask |= SupportCHTV;
    260. 

  260. 	 }
    261. 

  261.       }
    262. 

  262. 

  263.       if(SiS_Pr->SiS_VBInfo & SetCRT2ToLCD) {
    264. 

  264. 	 checkmask |= SupportLCD;
    265. 

  265.       }
    266. 

  266. 

  267.    }
    268. 

  268. 

  269.    /* Look backwards in table for matching CRT2 mode */
    270. 

  270.    for(; SiS_Pr->SiS_RefIndex[RRTI + (*i)].ModeID == modeid; (*i)--) {
    271. 

  271.       infoflag = SiS_Pr->SiS_RefIndex[RRTI + (*i)].Ext_InfoFlag;
    272. 

  272.       if(infoflag & checkmask) return true;
    273. 

  273.       if((*i) == 0) break;
    274. 

  274.    }
    275. 

  275. 

  276.    /* Look through the whole mode-section of the table from the beginning
    277. 

  277.     * for a matching CRT2 mode if no mode was found yet.
    278. 

  278.     */
    279. 

  279.    for((*i) = 0; ; (*i)++) {
    280. 

  280.       if(SiS_Pr->SiS_RefIndex[RRTI + (*i)].ModeID != modeid) break;
    281. 

  281.       infoflag = SiS_Pr->SiS_RefIndex[RRTI + (*i)].Ext_InfoFlag;
    282. 

  282.       if(infoflag & checkmask) return true;
    283. 

  283.    }
    284. 

  284.    return false;
    285. 

  285. }
    286. 

  286. 

  287. /*********************************************/
    288. 

  288. /*              Get rate index               */
    289. 

  289. /*********************************************/
    290. 

  290. 

  291. unsigned short
    292. 

  292. SiS_GetRatePtr(struct SiS_Private *SiS_Pr, unsigned short ModeNo, unsigned short ModeIdIndex)
    293. 

  293. {
    294. 

  294.    unsigned short RRTI,i,backup_i;
    295. 

  295.    unsigned short modeflag,index,temp,backupindex;
    296. 

  296.    static const unsigned short LCDRefreshIndex[] = {
    297. 

  297. 		0x00, 0x00, 0x01, 0x01,
    298. 

  298. 		0x01, 0x01, 0x01, 0x01,
    299. 

  299. 		0x01, 0x01, 0x01, 0x01,
    300. 

  300. 		0x01, 0x01, 0x01, 0x01,
    301. 

  301. 		0x00, 0x00, 0x00, 0x00
    302. 

  302.    };
    303. 

  303. 

  304.    /* Do NOT check for UseCustomMode here, will skrew up FIFO */
    305. 

  305.    if(ModeNo == 0xfe) return 0;
    306. 

  306. 

  307.    if(ModeNo <= 0x13) {
    308. 

  308.       modeflag = SiS_Pr->SiS_SModeIDTable[ModeIdIndex].St_ModeFlag;
    309. 

  309.    } else {
    310. 

  310.       modeflag = SiS_Pr->SiS_EModeIDTable[ModeIdIndex].Ext_ModeFlag;
    311. 

  311.    }
    312. 

  312. 

  313.    if(SiS_Pr->SiS_IF_DEF_CH70xx != 0) {
    314. 

  314.       if(SiS_Pr->SiS_VBInfo & SetCRT2ToTV) {
    315. 

  315. 	 if(modeflag & HalfDCLK) return 0;
    316. 

  316.       }
    317. 

  317.    }
    318. 

  318. 

  319.    if(ModeNo < 0x14) return 0xFFFF;
    320. 

  320. 

  321.    index = (SiS_GetReg(SiS_Pr->SiS_P3d4,0x33) >> SiS_Pr->SiS_SelectCRT2Rate) & 0x0F;
    322. 

  322.    backupindex = index;
    323. 

  323. 

  324.    if(index > 0) index--;
    325. 

  325. 

  326.    if(SiS_Pr->SiS_SetFlag & ProgrammingCRT2) {
    327. 

  327.       if(SiS_Pr->SiS_VBType & VB_SISVB) {
    328. 

  328. 	 if(SiS_Pr->SiS_VBInfo & SetCRT2ToLCD) {
    329. 

  329. 	    if(SiS_Pr->SiS_VBType & VB_NoLCD)		 index = 0;
    330. 

  330. 	    else if(SiS_Pr->SiS_LCDInfo & DontExpandLCD) index = backupindex = 0;
    331. 

  331. 	 }
    332. 

  332. 	 if(SiS_Pr->SiS_VBInfo & (SetCRT2ToLCD | SetCRT2ToLCDA)) {
    333. 

  333. 	    if(!(SiS_Pr->SiS_VBType & VB_NoLCD)) {
    334. 

  334. 	       temp = LCDRefreshIndex[SiS_GetBIOSLCDResInfo(SiS_Pr)];
    335. 

  335. 	       if(index > temp) index = temp;
    336. 

  336. 	    }
    337. 

  337. 	 }
    338. 

  338.       } else {
    339. 

  339. 	 if(SiS_Pr->SiS_VBInfo & (SetCRT2ToLCD | SetCRT2ToLCDA)) index = 0;
    340. 

  340. 	 if(SiS_Pr->SiS_IF_DEF_CH70xx != 0) {
    341. 

  341. 	    if(SiS_Pr->SiS_VBInfo & SetCRT2ToTV) index = 0;
    342. 

  342. 	 }
    343. 

  343.       }
    344. 

  344.    }
    345. 

  345. 

  346.    RRTI = SiS_Pr->SiS_EModeIDTable[ModeIdIndex].REFindex;
    347. 

  347.    ModeNo = SiS_Pr->SiS_RefIndex[RRTI].ModeID;
    348. 

  348. 

  349.    if(SiS_Pr->ChipType >= SIS_315H) {
    350. 

  350.       if(!(SiS_Pr->SiS_VBInfo & DriverMode)) {
    351. 

  351. 	 if( (SiS_Pr->SiS_EModeIDTable[ModeIdIndex].Ext_VESAID == 0x105) ||
    352. 

  352. 	     (SiS_Pr->SiS_EModeIDTable[ModeIdIndex].Ext_VESAID == 0x107) ) {
    353. 

  353. 	    if(backupindex <= 1) RRTI++;
    354. 

  354. 	 }
    355. 

  355.       }
    356. 

  356.    }
    357. 

  357. 

  358.    i = 0;
    359. 

  359.    do {
    360. 

  360.       if(SiS_Pr->SiS_RefIndex[RRTI + i].ModeID != ModeNo) break;
    361. 

  361.       temp = SiS_Pr->SiS_RefIndex[RRTI + i].Ext_InfoFlag;
    362. 

  362.       temp &= ModeTypeMask;
    363. 

  363.       if(temp < SiS_Pr->SiS_ModeType) break;
    364. 

  364.       i++;
    365. 

  365.       index--;
    366. 

  366.    } while(index != 0xFFFF);
    367. 

  367. 

  368.    if(!(SiS_Pr->SiS_VBInfo & SetCRT2ToRAMDAC)) {
    369. 

  369.       if(SiS_Pr->SiS_VBInfo & SetInSlaveMode) {
    370. 

  370. 	 temp = SiS_Pr->SiS_RefIndex[RRTI + i - 1].Ext_InfoFlag;
    371. 

  371. 	 if(temp & InterlaceMode) i++;
    372. 

  372.       }
    373. 

  373.    }
    374. 

  374. 

  375.    i--;
    376. 

  376. 

  377.    if((SiS_Pr->SiS_SetFlag & ProgrammingCRT2) && (!(SiS_Pr->SiS_VBInfo & DisableCRT2Display))) {
    378. 

  378.       backup_i = i;
    379. 

  379.       if(!(SiS_AdjustCRT2Rate(SiS_Pr, ModeNo, ModeIdIndex, RRTI, &i))) {
    380. 

  380. 	 i = backup_i;
    381. 

  381.       }
    382. 

  382.    }
    383. 

  383. 

  384.    return (RRTI + i);
    385. 

  385. }
    386. 

  386. 

  387. /*********************************************/
    388. 

  388. /*            STORE CRT2 INFO in CR34        */
    389. 

  389. /*********************************************/
    390. 

  390. 

  391. static void
    392. 

  392. SiS_SaveCRT2Info(struct SiS_Private *SiS_Pr, unsigned short ModeNo)
    393. 

  393. {
    394. 

  394.    unsigned short temp1, temp2;
    395. 

  395. 

  396.    /* Store CRT1 ModeNo in CR34 */
    397. 

  397.    SiS_SetReg(SiS_Pr->SiS_P3d4,0x34,ModeNo);
    398. 

  398.    temp1 = (SiS_Pr->SiS_VBInfo & SetInSlaveMode) >> 8;
    399. 

  399.    temp2 = ~(SetInSlaveMode >> 8);
    400. 

  400.    SiS_SetRegANDOR(SiS_Pr->SiS_P3d4,0x31,temp2,temp1);
    401. 

  401. }
    402. 

  402. 

  403. /*********************************************/
    404. 

  404. /*    HELPER: GET SOME DATA FROM BIOS ROM    */
    405. 

  405. /*********************************************/
    406. 

  406. 

  407. #ifdef SIS300
    408. 

  408. static bool
    409. 

  409. SiS_CR36BIOSWord23b(struct SiS_Private *SiS_Pr)
    410. 

  410. {
    411. 

  411.    unsigned char  *ROMAddr = SiS_Pr->VirtualRomBase;
    412. 

  412.    unsigned short temp,temp1;
    413. 

  413. 

  414.    if(SiS_Pr->SiS_UseROM) {
    415. 

  415.       if((ROMAddr[0x233] == 0x12) && (ROMAddr[0x234] == 0x34)) {
    416. 

  416. 	 temp = 1 << ((SiS_GetReg(SiS_Pr->SiS_P3d4,0x36) >> 4) & 0x0f);
    417. 

  417. 	 temp1 = SISGETROMW(0x23b);
    418. 

  418. 	 if(temp1 & temp) return true;
    419. 

  419.       }
    420. 

  420.    }
    421. 

  421.    return false;
    422. 

  422. }
    423. 

  423. 

  424. static bool
    425. 

  425. SiS_CR36BIOSWord23d(struct SiS_Private *SiS_Pr)
    426. 

  426. {
    427. 

  427.    unsigned char  *ROMAddr = SiS_Pr->VirtualRomBase;
    428. 

  428.    unsigned short temp,temp1;
    429. 

  429. 

  430.    if(SiS_Pr->SiS_UseROM) {
    431. 

  431.       if((ROMAddr[0x233] == 0x12) && (ROMAddr[0x234] == 0x34)) {
    432. 

  432. 	 temp = 1 << ((SiS_GetReg(SiS_Pr->SiS_P3d4,0x36) >> 4) & 0x0f);
    433. 

  433. 	 temp1 = SISGETROMW(0x23d);
    434. 

  434. 	 if(temp1 & temp) return true;
    435. 

  435.       }
    436. 

  436.    }
    437. 

  437.    return false;
    438. 

  438. }
    439. 

  439. #endif
    440. 

  440. 

  441. /*********************************************/
    442. 

  442. /*          HELPER: DELAY FUNCTIONS          */
    443. 

  443. /*********************************************/
    444. 

  444. 

  445. void
    446. 

  446. SiS_DDC2Delay(struct SiS_Private *SiS_Pr, unsigned int delaytime)
    447. 

  447. {
    448. 

  448.    while (delaytime-- > 0)
    449. 

  449.       SiS_GetReg(SiS_Pr->SiS_P3c4, 0x05);
    450. 

  450. }
    451. 

  451. 

  452. #if defined(SIS300) || defined(SIS315H)
    453. 

  453. static void
    454. 

  454. SiS_GenericDelay(struct SiS_Private *SiS_Pr, unsigned short delay)
    455. 

  455. {
    456. 

  456.    SiS_DDC2Delay(SiS_Pr, delay * 36);
    457. 

  457. }
    458. 

  458. #endif
    459. 

  459. 

  460. #ifdef SIS315H
    461. 

  461. static void
    462. 

  462. SiS_LongDelay(struct SiS_Private *SiS_Pr, unsigned short delay)
    463. 

  463. {
    464. 

  464.    while(delay--) {
    465. 

  465.       SiS_GenericDelay(SiS_Pr, 6623);
    466. 

  466.    }
    467. 

  467. }
    468. 

  468. #endif
    469. 

  469. 

  470. #if defined(SIS300) || defined(SIS315H)
    471. 

  471. static void
    472. 

  472. SiS_ShortDelay(struct SiS_Private *SiS_Pr, unsigned short delay)
    473. 

  473. {
    474. 

  474.    while(delay--) {
    475. 

  475.       SiS_GenericDelay(SiS_Pr, 66);
    476. 

  476.    }
    477. 

  477. }
    478. 

  478. #endif
    479. 

  479. 

  480. static void
    481. 

  481. SiS_PanelDelay(struct SiS_Private *SiS_Pr, unsigned short DelayTime)
    482. 

  482. {
    483. 

  483. #if defined(SIS300) || defined(SIS315H)
    484. 

  484.    unsigned char  *ROMAddr = SiS_Pr->VirtualRomBase;
    485. 

  485.    unsigned short PanelID, DelayIndex, Delay=0;
    486. 

  486. #endif
    487. 

  487. 

  488.    if(SiS_Pr->ChipType < SIS_315H) {
    489. 

  489. 

  490. #ifdef SIS300
    491. 

  491. 

  492.       PanelID = SiS_GetReg(SiS_Pr->SiS_P3d4,0x36);
    493. 

  493.       if(SiS_Pr->SiS_VBType & VB_SISVB) {
    494. 

  494. 	 if(SiS_Pr->SiS_VBType & VB_SIS301) PanelID &= 0xf7;
    495. 

  495. 	 if(!(SiS_GetReg(SiS_Pr->SiS_P3c4,0x18) & 0x10)) PanelID = 0x12;
    496. 

  496.       }
    497. 

  497.       DelayIndex = PanelID >> 4;
    498. 

  498.       if((DelayTime >= 2) && ((PanelID & 0x0f) == 1))  {
    499. 

  499. 	 Delay = 3;
    500. 

  500.       } else {
    501. 

  501. 	 if(DelayTime >= 2) DelayTime -= 2;
    502. 

  502. 	 if(!(DelayTime & 0x01)) {
    503. 

  503. 	    Delay = SiS_Pr->SiS_PanelDelayTbl[DelayIndex].timer[0];
    504. 

  504. 	 } else {
    505. 

  505. 	    Delay = SiS_Pr->SiS_PanelDelayTbl[DelayIndex].timer[1];
    506. 

  506. 	 }
    507. 

  507. 	 if(SiS_Pr->SiS_UseROM) {
    508. 

  508. 	    if(ROMAddr[0x220] & 0x40) {
    509. 

  509. 	       if(!(DelayTime & 0x01)) Delay = (unsigned short)ROMAddr[0x225];
    510. 

  510. 	       else 	    	       Delay = (unsigned short)ROMAddr[0x226];
    511. 

  511. 	    }
    512. 

  512. 	 }
    513. 

  513.       }
    514. 

  514.       SiS_ShortDelay(SiS_Pr, Delay);
    515. 

  515. 

  516. #endif  /* SIS300 */
    517. 

  517. 

  518.    } else {
    519. 

  519. 

  520. #ifdef SIS315H
    521. 

  521. 

  522.       if((SiS_Pr->ChipType >= SIS_661)    ||
    523. 

  523. 	 (SiS_Pr->ChipType <= SIS_315PRO) ||
    524. 

  524. 	 (SiS_Pr->ChipType == SIS_330)    ||
    525. 

  525. 	 (SiS_Pr->SiS_ROMNew)) {
    526. 

  526. 

  527. 	 if(!(DelayTime & 0x01)) {
    528. 

  528. 	    SiS_DDC2Delay(SiS_Pr, 0x1000);
    529. 

  529. 	 } else {
    530. 

  530. 	    SiS_DDC2Delay(SiS_Pr, 0x4000);
    531. 

  531. 	 }
    532. 

  532. 

  533.       } else if((SiS_Pr->SiS_IF_DEF_LVDS == 1) /* ||
    534. 

  534. 	 (SiS_Pr->SiS_CustomT == CUT_COMPAQ1280) ||
    535. 

  535. 	 (SiS_Pr->SiS_CustomT == CUT_CLEVO1400) */ ) {			/* 315 series, LVDS; Special */
    536. 

  536. 

  537. 	 if(SiS_Pr->SiS_IF_DEF_CH70xx == 0) {
    538. 

  538. 	    PanelID = SiS_GetReg(SiS_Pr->SiS_P3d4,0x36);
    539. 

  539. 	    if(SiS_Pr->SiS_CustomT == CUT_CLEVO1400) {
    540. 

  540. 	       if(!(SiS_GetReg(SiS_Pr->SiS_P3c4,0x1b) & 0x10)) PanelID = 0x12;
    541. 

  541. 	    }
    542. 

  542. 	    if(SiS_Pr->SiS_CustomT == CUT_COMPAQ1280) {
    543. 

  543. 	       DelayIndex = PanelID & 0x0f;
    544. 

  544. 	    } else {
    545. 

  545. 	       DelayIndex = PanelID >> 4;
    546. 

  546. 	    }
    547. 

  547. 	    if((DelayTime >= 2) && ((PanelID & 0x0f) == 1))  {
    548. 

  548. 	       Delay = 3;
    549. 

  549. 	    } else {
    550. 

  550. 	       if(DelayTime >= 2) DelayTime -= 2;
    551. 

  551. 	       if(!(DelayTime & 0x01)) {
    552. 

  552. 		  Delay = SiS_Pr->SiS_PanelDelayTblLVDS[DelayIndex].timer[0];
    553. 

  553. 		} else {
    554. 

  554. 		  Delay = SiS_Pr->SiS_PanelDelayTblLVDS[DelayIndex].timer[1];
    555. 

  555. 	       }
    556. 

  556. 	       if((SiS_Pr->SiS_UseROM) && (!(SiS_Pr->SiS_ROMNew))) {
    557. 

  557. 		  if(ROMAddr[0x13c] & 0x40) {
    558. 

  558. 		     if(!(DelayTime & 0x01)) {
    559. 

  559. 			Delay = (unsigned short)ROMAddr[0x17e];
    560. 

  560. 		     } else {
    561. 

  561. 			Delay = (unsigned short)ROMAddr[0x17f];
    562. 

  562. 		     }
    563. 

  563. 		  }
    564. 

  564. 	       }
    565. 

  565. 	    }
    566. 

  566. 	    SiS_ShortDelay(SiS_Pr, Delay);
    567. 

  567. 	 }
    568. 

  568. 

  569.       } else if(SiS_Pr->SiS_VBType & VB_SISVB) {			/* 315 series, all bridges */
    570. 

  570. 

  571. 	 DelayIndex = SiS_GetReg(SiS_Pr->SiS_P3d4,0x36) >> 4;
    572. 

  572. 	 if(!(DelayTime & 0x01)) {
    573. 

  573. 	    Delay = SiS_Pr->SiS_PanelDelayTbl[DelayIndex].timer[0];
    574. 

  574. 	 } else {
    575. 

  575. 	    Delay = SiS_Pr->SiS_PanelDelayTbl[DelayIndex].timer[1];
    576. 

  576. 	 }
    577. 

  577. 	 Delay <<= 8;
    578. 

  578. 	 SiS_DDC2Delay(SiS_Pr, Delay);
    579. 

  579. 

  580.       }
    581. 

  581. 

  582. #endif /* SIS315H */
    583. 

  583. 

  584.    }
    585. 

  585. }
    586. 

  586. 

  587. #ifdef SIS315H
    588. 

  588. static void
    589. 

  589. SiS_PanelDelayLoop(struct SiS_Private *SiS_Pr, unsigned short DelayTime, unsigned short DelayLoop)
    590. 

  590. {
    591. 

  591.    int i;
    592. 

  592.    for(i = 0; i < DelayLoop; i++) {
    593. 

  593.       SiS_PanelDelay(SiS_Pr, DelayTime);
    594. 

  594.    }
    595. 

  595. }
    596. 

  596. #endif
    597. 

  597. 

  598. /*********************************************/
    599. 

  599. /*    HELPER: WAIT-FOR-RETRACE FUNCTIONS     */
    600. 

  600. /*********************************************/
    601. 

  601. 

  602. void
    603. 

  603. SiS_WaitRetrace1(struct SiS_Private *SiS_Pr)
    604. 

  604. {
    605. 

  605.    unsigned short watchdog;
    606. 

  606. 

  607.    if(SiS_GetReg(SiS_Pr->SiS_P3c4,0x1f) & 0xc0) return;
    608. 

  608.    if(!(SiS_GetReg(SiS_Pr->SiS_P3d4,0x17) & 0x80)) return;
    609. 

  609. 

  610.    watchdog = 65535;
    611. 

  611.    while((SiS_GetRegByte(SiS_Pr->SiS_P3da) & 0x08) && --watchdog);
    612. 

  612.    watchdog = 65535;
    613. 

  613.    while((!(SiS_GetRegByte(SiS_Pr->SiS_P3da) & 0x08)) && --watchdog);
    614. 

  614. }
    615. 

  615. 

  616. #if defined(SIS300) || defined(SIS315H)
    617. 

  617. static void
    618. 

  618. SiS_WaitRetrace2(struct SiS_Private *SiS_Pr, unsigned short reg)
    619. 

  619. {
    620. 

  620.    unsigned short watchdog;
    621. 

  621. 

  622.    watchdog = 65535;
    623. 

  623.    while((SiS_GetReg(SiS_Pr->SiS_Part1Port,reg) & 0x02) && --watchdog);
    624. 

  624.    watchdog = 65535;
    625. 

  625.    while((!(SiS_GetReg(SiS_Pr->SiS_Part1Port,reg) & 0x02)) && --watchdog);
    626. 

  626. }
    627. 

  627. #endif
    628. 

  628. 

  629. static void
    630. 

  630. SiS_WaitVBRetrace(struct SiS_Private *SiS_Pr)
    631. 

  631. {
    632. 

  632.    if(SiS_Pr->ChipType < SIS_315H) {
    633. 

  633. #ifdef SIS300
    634. 

  634.       if(SiS_Pr->SiS_VBType & VB_SIS30xBLV) {
    635. 

  635. 	 if(!(SiS_GetReg(SiS_Pr->SiS_Part1Port,0x00) & 0x20)) return;
    636. 

  636.       }
    637. 

  637.       if(!(SiS_GetReg(SiS_Pr->SiS_Part1Port,0x00) & 0x80)) {
    638. 

  638. 	 SiS_WaitRetrace1(SiS_Pr);
    639. 

  639.       } else {
    640. 

  640. 	 SiS_WaitRetrace2(SiS_Pr, 0x25);
    641. 

  641.       }
    642. 

  642. #endif
    643. 

  643.    } else {
    644. 

  644. #ifdef SIS315H
    645. 

  645.       if(!(SiS_GetReg(SiS_Pr->SiS_Part1Port,0x00) & 0x40)) {
    646. 

  646. 	 SiS_WaitRetrace1(SiS_Pr);
    647. 

  647.       } else {
    648. 

  648. 	 SiS_WaitRetrace2(SiS_Pr, 0x30);
    649. 

  649.       }
    650. 

  650. #endif
    651. 

  651.    }
    652. 

  652. }
    653. 

  653. 

  654. static void
    655. 

  655. SiS_VBWait(struct SiS_Private *SiS_Pr)
    656. 

  656. {
    657. 

  657.    unsigned short tempal,temp,i,j;
    658. 

  658. 

  659.    temp = 0;
    660. 

  660.    for(i = 0; i < 3; i++) {
    661. 

  661.      for(j = 0; j < 100; j++) {
    662. 

  662.         tempal = SiS_GetRegByte(SiS_Pr->SiS_P3da);
    663. 

  663.         if(temp & 0x01) {
    664. 

  664. 	   if((tempal & 0x08))  continue;
    665. 

  665. 	   else break;
    666. 

  666.         } else {
    667. 

  667. 	   if(!(tempal & 0x08)) continue;
    668. 

  668. 	   else break;
    669. 

  669.         }
    670. 

  670.      }
    671. 

  671.      temp ^= 0x01;
    672. 

  672.    }
    673. 

  673. }
    674. 

  674. 

  675. static void
    676. 

  676. SiS_VBLongWait(struct SiS_Private *SiS_Pr)
    677. 

  677. {
    678. 

  678.    if(SiS_Pr->SiS_VBInfo & SetCRT2ToTV) {
    679. 

  679.       SiS_VBWait(SiS_Pr);
    680. 

  680.    } else {
    681. 

  681.       SiS_WaitRetrace1(SiS_Pr);
    682. 

  682.    }
    683. 

  683. }
    684. 

  684. 

  685. /*********************************************/
    686. 

  686. /*               HELPER: MISC                */
    687. 

  687. /*********************************************/
    688. 

  688. 

  689. #ifdef SIS300
    690. 

  690. static bool
    691. 

  691. SiS_Is301B(struct SiS_Private *SiS_Pr)
    692. 

  692. {
    693. 

  693.    if(SiS_GetReg(SiS_Pr->SiS_Part4Port,0x01) >= 0xb0) return true;
    694. 

  694.    return false;
    695. 

  695. }
    696. 

  696. #endif
    697. 

  697. 

  698. static bool
    699. 

  699. SiS_CRT2IsLCD(struct SiS_Private *SiS_Pr)
    700. 

  700. {
    701. 

  701.    if(SiS_Pr->ChipType == SIS_730) {
    702. 

  702.       if(SiS_GetReg(SiS_Pr->SiS_P3c4,0x13) & 0x20) return true;
    703. 

  703.    }
    704. 

  704.    if(SiS_GetReg(SiS_Pr->SiS_P3d4,0x30) & 0x20) return true;
    705. 

  705.    return false;
    706. 

  706. }
    707. 

  707. 

  708. bool
    709. 

  709. SiS_IsDualEdge(struct SiS_Private *SiS_Pr)
    710. 

  710. {
    711. 

  711. #ifdef SIS315H
    712. 

  712.    if(SiS_Pr->ChipType >= SIS_315H) {
    713. 

  713.       if((SiS_Pr->ChipType != SIS_650) || (SiS_GetReg(SiS_Pr->SiS_P3d4,0x5f) & 0xf0)) {
    714. 

  714. 	 if(SiS_GetReg(SiS_Pr->SiS_P3d4,0x38) & EnableDualEdge) return true;
    715. 

  715.       }
    716. 

  716.    }
    717. 

  717. #endif
    718. 

  718.    return false;
    719. 

  719. }
    720. 

  720. 

  721. bool
    722. 

  722. SiS_IsVAMode(struct SiS_Private *SiS_Pr)
    723. 

  723. {
    724. 

  724. #ifdef SIS315H
    725. 

  725.    unsigned short flag;
    726. 

  726. 

  727.    if(SiS_Pr->ChipType >= SIS_315H) {
    728. 

  728.       flag = SiS_GetReg(SiS_Pr->SiS_P3d4,0x38);
    729. 

  729.       if((flag & EnableDualEdge) && (flag & SetToLCDA)) return true;
    730. 

  730.    }
    731. 

  731. #endif
    732. 

  732.    return false;
    733. 

  733. }
    734. 

  734. 

  735. #ifdef SIS315H
    736. 

  736. static bool
    737. 

  737. SiS_IsVAorLCD(struct SiS_Private *SiS_Pr)
    738. 

  738. {
    739. 

  739.    if(SiS_IsVAMode(SiS_Pr))  return true;
    740. 

  740.    if(SiS_CRT2IsLCD(SiS_Pr)) return true;
    741. 

  741.    return false;
    742. 

  742. }
    743. 

  743. #endif
    744. 

  744. 

  745. static bool
    746. 

  746. SiS_IsDualLink(struct SiS_Private *SiS_Pr)
    747. 

  747. {
    748. 

  748. #ifdef SIS315H
    749. 

  749.    if(SiS_Pr->ChipType >= SIS_315H) {
    750. 

  750.       if((SiS_CRT2IsLCD(SiS_Pr)) ||
    751. 

  751.          (SiS_IsVAMode(SiS_Pr))) {
    752. 

  752. 	 if(SiS_Pr->SiS_LCDInfo & LCDDualLink) return true;
    753. 

  753.       }
    754. 

  754.    }
    755. 

  755. #endif
    756. 

  756.    return false;
    757. 

  757. }
    758. 

  758. 

  759. #ifdef SIS315H
    760. 

  760. static bool
    761. 

  761. SiS_TVEnabled(struct SiS_Private *SiS_Pr)
    762. 

  762. {
    763. 

  763.    if((SiS_GetReg(SiS_Pr->SiS_Part2Port,0x00) & 0x0f) != 0x0c) return true;
    764. 

  764.    if(SiS_Pr->SiS_VBType & VB_SISYPBPR) {
    765. 

  765.       if(SiS_GetReg(SiS_Pr->SiS_Part2Port,0x4d) & 0x10) return true;
    766. 

  766.    }
    767. 

  767.    return false;
    768. 

  768. }
    769. 

  769. #endif
    770. 

  770. 

  771. #ifdef SIS315H
    772. 

  772. static bool
    773. 

  773. SiS_LCDAEnabled(struct SiS_Private *SiS_Pr)
    774. 

  774. {
    775. 

  775.    if(SiS_GetReg(SiS_Pr->SiS_Part1Port,0x13) & 0x04) return true;
    776. 

  776.    return false;
    777. 

  777. }
    778. 

  778. #endif
    779. 

  779. 

  780. #ifdef SIS315H
    781. 

  781. static bool
    782. 

  782. SiS_WeHaveBacklightCtrl(struct SiS_Private *SiS_Pr)
    783. 

  783. {
    784. 

  784.    if((SiS_Pr->ChipType >= SIS_315H) && (SiS_Pr->ChipType < SIS_661)) {
    785. 

  785.       if(SiS_GetReg(SiS_Pr->SiS_P3d4,0x79) & 0x10) return true;
    786. 

  786.    }
    787. 

  787.    return false;
    788. 

  788. }
    789. 

  789. #endif
    790. 

  790. 

  791. #ifdef SIS315H
    792. 

  792. static bool
    793. 

  793. SiS_IsNotM650orLater(struct SiS_Private *SiS_Pr)
    794. 

  794. {
    795. 

  795.    unsigned short flag;
    796. 

  796. 

  797.    if(SiS_Pr->ChipType == SIS_650) {
    798. 

  798.       flag = SiS_GetReg(SiS_Pr->SiS_P3d4,0x5f) & 0xf0;
    799. 

  799.       /* Check for revision != A0 only */
    800. 

  800.       if((flag == 0xe0) || (flag == 0xc0) ||
    801. 

  801.          (flag == 0xb0) || (flag == 0x90)) return false;
    802. 

  802.    } else if(SiS_Pr->ChipType >= SIS_661) return false;
    803. 

  803.    return true;
    804. 

  804. }
    805. 

  805. #endif
    806. 

  806. 

  807. #ifdef SIS315H
    808. 

  808. static bool
    809. 

  809. SiS_IsYPbPr(struct SiS_Private *SiS_Pr)
    810. 

  810. {
    811. 

  811.    if(SiS_Pr->ChipType >= SIS_315H) {
    812. 

  812.       /* YPrPb = 0x08 */
    813. 

  813.       if(SiS_GetReg(SiS_Pr->SiS_P3d4,0x38) & EnableCHYPbPr) return true;
    814. 

  814.    }
    815. 

  815.    return false;
    816. 

  816. }
    817. 

  817. #endif
    818. 

  818. 

  819. #ifdef SIS315H
    820. 

  820. static bool
    821. 

  821. SiS_IsChScart(struct SiS_Private *SiS_Pr)
    822. 

  822. {
    823. 

  823.    if(SiS_Pr->ChipType >= SIS_315H) {
    824. 

  824.       /* Scart = 0x04 */
    825. 

  825.       if(SiS_GetReg(SiS_Pr->SiS_P3d4,0x38) & EnableCHScart) return true;
    826. 

  826.    }
    827. 

  827.    return false;
    828. 

  828. }
    829. 

  829. #endif
    830. 

  830. 

  831. #ifdef SIS315H
    832. 

  832. static bool
    833. 

  833. SiS_IsTVOrYPbPrOrScart(struct SiS_Private *SiS_Pr)
    834. 

  834. {
    835. 

  835.    unsigned short flag;
    836. 

  836. 

  837.    if(SiS_Pr->ChipType >= SIS_315H) {
    838. 

  838.       flag = SiS_GetReg(SiS_Pr->SiS_P3d4,0x30);
    839. 

  839.       if(flag & SetCRT2ToTV)        return true;
    840. 

  840.       flag = SiS_GetReg(SiS_Pr->SiS_P3d4,0x38);
    841. 

  841.       if(flag & EnableCHYPbPr)      return true;  /* = YPrPb = 0x08 */
    842. 

  842.       if(flag & EnableCHScart)      return true;  /* = Scart = 0x04 - TW */
    843. 

  843.    } else {
    844. 

  844.       flag = SiS_GetReg(SiS_Pr->SiS_P3d4,0x30);
    845. 

  845.       if(flag & SetCRT2ToTV)        return true;
    846. 

  846.    }
    847. 

  847.    return false;
    848. 

  848. }
    849. 

  849. #endif
    850. 

  850. 

  851. #ifdef SIS315H
    852. 

  852. static bool
    853. 

  853. SiS_IsLCDOrLCDA(struct SiS_Private *SiS_Pr)
    854. 

  854. {
    855. 

  855.    unsigned short flag;
    856. 

  856. 

  857.    if(SiS_Pr->ChipType >= SIS_315H) {
    858. 

  858.       flag = SiS_GetReg(SiS_Pr->SiS_P3d4,0x30);
    859. 

  859.       if(flag & SetCRT2ToLCD) return true;
    860. 

  860.       flag = SiS_GetReg(SiS_Pr->SiS_P3d4,0x38);
    861. 

  861.       if(flag & SetToLCDA)    return true;
    862. 

  862.    } else {
    863. 

  863.       flag = SiS_GetReg(SiS_Pr->SiS_P3d4,0x30);
    864. 

  864.       if(flag & SetCRT2ToLCD) return true;
    865. 

  865.    }
    866. 

  866.    return false;
    867. 

  867. }
    868. 

  868. #endif
    869. 

  869. 

  870. static bool
    871. 

  871. SiS_HaveBridge(struct SiS_Private *SiS_Pr)
    872. 

  872. {
    873. 

  873.    unsigned short flag;
    874. 

  874. 

  875.    if(SiS_Pr->SiS_IF_DEF_LVDS == 1) {
    876. 

  876.       return true;
    877. 

  877.    } else if(SiS_Pr->SiS_VBType & VB_SISVB) {
    878. 

  878.       flag = SiS_GetReg(SiS_Pr->SiS_Part4Port,0x00);
    879. 

  879.       if((flag == 1) || (flag == 2)) return true;
    880. 

  880.    }
    881. 

  881.    return false;
    882. 

  882. }
    883. 

  883. 

  884. static bool
    885. 

  885. SiS_BridgeIsEnabled(struct SiS_Private *SiS_Pr)
    886. 

  886. {
    887. 

  887.    unsigned short flag;
    888. 

  888. 

  889.    if(SiS_HaveBridge(SiS_Pr)) {
    890. 

  890.       flag = SiS_GetReg(SiS_Pr->SiS_Part1Port,0x00);
    891. 

  891.       if(SiS_Pr->ChipType < SIS_315H) {
    892. 

  892. 	flag &= 0xa0;
    893. 

  893. 	if((flag == 0x80) || (flag == 0x20)) return true;
    894. 

  894.       } else {
    895. 

  895. 	flag &= 0x50;
    896. 

  896. 	if((flag == 0x40) || (flag == 0x10)) return true;
    897. 

  897.       }
    898. 

  898.    }
    899. 

  899.    return false;
    900. 

  900. }
    901. 

  901. 

  902. static bool
    903. 

  903. SiS_BridgeInSlavemode(struct SiS_Private *SiS_Pr)
    904. 

  904. {
    905. 

  905.    unsigned short flag1;
    906. 

  906. 

  907.    flag1 = SiS_GetReg(SiS_Pr->SiS_P3d4,0x31);
    908. 

  908.    if(flag1 & (SetInSlaveMode >> 8)) return true;
    909. 

  909.    return false;
    910. 

  910. }
    911. 

  911. 

  912. /*********************************************/
    913. 

  913. /*       GET VIDEO BRIDGE CONFIG INFO        */
    914. 

  914. /*********************************************/
    915. 

  915. 

  916. /* Setup general purpose IO for Chrontel communication */
    917. 

  917. #ifdef SIS300
    918. 

  918. void
    919. 

  919. SiS_SetChrontelGPIO(struct SiS_Private *SiS_Pr, unsigned short myvbinfo)
    920. 

  920. {
    921. 

  921.    unsigned int   acpibase;
    922. 

  922.    unsigned short temp;
    923. 

  923. 

  924.    if(!(SiS_Pr->SiS_ChSW)) return;
    925. 

  925. 

  926. #ifdef SIS_LINUX_KERNEL
    927. 

  927.    acpibase = sisfb_read_lpc_pci_dword(SiS_Pr, 0x74);
    928. 

  928. #else
    929. 

  929.    acpibase = pciReadLong(0x00000800, 0x74);
    930. 

  930. #endif
    931. 

  931.    acpibase &= 0xFFFF;
    932. 

  932.    if(!acpibase) return;
    933. 

  933.    temp = SiS_GetRegShort((acpibase + 0x3c));	/* ACPI register 0x3c: GP Event 1 I/O mode select */
    934. 

  934.    temp &= 0xFEFF;
    935. 

  935.    SiS_SetRegShort((acpibase + 0x3c), temp);
    936. 

  936.    temp = SiS_GetRegShort((acpibase + 0x3c));
    937. 

  937.    temp = SiS_GetRegShort((acpibase + 0x3a));	/* ACPI register 0x3a: GP Pin Level (low/high) */
    938. 

  938.    temp &= 0xFEFF;
    939. 

  939.    if(!(myvbinfo & SetCRT2ToTV)) temp |= 0x0100;
    940. 

  940.    SiS_SetRegShort((acpibase + 0x3a), temp);
    941. 

  941.    temp = SiS_GetRegShort((acpibase + 0x3a));
    942. 

  942. }
    943. 

  943. #endif
    944. 

  944. 

  945. void
    946. 

  946. SiS_GetVBInfo(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
    947. 

  947. 		unsigned short ModeIdIndex, int checkcrt2mode)
    948. 

  948. {
    949. 

  949.    unsigned short tempax, tempbx, temp;
    950. 

  950.    unsigned short modeflag, resinfo = 0;
    951. 

  951. 

  952.    SiS_Pr->SiS_SetFlag = 0;
    953. 

  953. 

  954.    modeflag = SiS_GetModeFlag(SiS_Pr, ModeNo, ModeIdIndex);
    955. 

  955. 

  956.    SiS_Pr->SiS_ModeType = modeflag & ModeTypeMask;
    957. 

  957. 

  958.    if((ModeNo > 0x13) && (!SiS_Pr->UseCustomMode)) {
    959. 

  959.       resinfo = SiS_Pr->SiS_EModeIDTable[ModeIdIndex].Ext_RESINFO;
    960. 

  960.    }
    961. 

  961. 

  962.    tempbx = 0;
    963. 

  963. 

  964.    if(SiS_HaveBridge(SiS_Pr)) {
    965. 

  965. 

  966. 	temp = SiS_GetReg(SiS_Pr->SiS_P3d4,0x30);
    967. 

  967. 	tempbx |= temp;
    968. 

  968. 	tempax = SiS_GetReg(SiS_Pr->SiS_P3d4,0x31) << 8;
    969. 

  969. 	tempax &= (DriverMode | LoadDACFlag | SetNotSimuMode | SetPALTV);
    970. 

  970. 	tempbx |= tempax;
    971. 

  971. 

  972. #ifdef SIS315H
    973. 

  973. 	if(SiS_Pr->ChipType >= SIS_315H) {
    974. 

  974. 	   if(SiS_Pr->SiS_VBType & VB_SISLCDA) {
    975. 

  975. 	      if(ModeNo == 0x03) {
    976. 

  976. 		 /* Mode 0x03 is never in driver mode */
    977. 

  977. 		 SiS_SetRegAND(SiS_Pr->SiS_P3d4,0x31,0xbf);
    978. 

  978. 	      }
    979. 

  979. 	      if(!(SiS_GetReg(SiS_Pr->SiS_P3d4,0x31) & (DriverMode >> 8))) {
    980. 

  980. 		 /* Reset LCDA setting if not driver mode */
    981. 

  981. 		 SiS_SetRegAND(SiS_Pr->SiS_P3d4,0x38,0xfc);
    982. 

  982. 	      }
    983. 

  983. 	      if(IS_SIS650) {
    984. 

  984. 		 if(SiS_Pr->SiS_UseLCDA) {
    985. 

  985. 		    if(SiS_GetReg(SiS_Pr->SiS_P3d4,0x5f) & 0xF0) {
    986. 

  986. 		       if((ModeNo <= 0x13) || (!(SiS_GetReg(SiS_Pr->SiS_P3d4,0x31) & (DriverMode >> 8)))) {
    987. 

  987. 			  SiS_SetRegOR(SiS_Pr->SiS_P3d4,0x38,(EnableDualEdge | SetToLCDA));
    988. 

  988. 		       }
    989. 

  989. 		    }
    990. 

  990. 		 }
    991. 

  991. 	      }
    992. 

  992. 	      temp = SiS_GetReg(SiS_Pr->SiS_P3d4,0x38);
    993. 

  993. 	      if((temp & (EnableDualEdge | SetToLCDA)) == (EnableDualEdge | SetToLCDA)) {
    994. 

  994. 		 tempbx |= SetCRT2ToLCDA;
    995. 

  995. 	      }
    996. 

  996. 	   }
    997. 

  997. 

  998. 	   if(SiS_Pr->ChipType >= SIS_661) { /* New CR layout */
    999. 

  999. 	      tempbx &= ~(SetCRT2ToYPbPr525750 | SetCRT2ToHiVision);
    1000. 

  1000. 	      if(SiS_GetReg(SiS_Pr->SiS_P3d4,0x38) & 0x04) {
    1001. 

  1001. 		 temp = SiS_GetReg(SiS_Pr->SiS_P3d4,0x35) & 0xe0;
    1002. 

  1002. 		 if(temp == 0x60) tempbx |= SetCRT2ToHiVision;
    1003. 

  1003. 		 else if(SiS_Pr->SiS_VBType & VB_SISYPBPR) {
    1004. 

  1004. 		    tempbx |= SetCRT2ToYPbPr525750;
    1005. 

  1005. 		 }
    1006. 

  1006. 	      }
    1007. 

  1007. 	   }
    1008. 

  1008. 

  1009. 	   if(SiS_Pr->SiS_IF_DEF_LVDS == 1) {
    1010. 

  1010. 	      temp = SiS_GetReg(SiS_Pr->SiS_P3d4,0x38);
    1011. 

  1011. 	      if(temp & SetToLCDA) {
    1012. 

  1012. 		 tempbx |= SetCRT2ToLCDA;
    1013. 

  1013. 	      }
    1014. 

  1014. 	      if(SiS_Pr->SiS_IF_DEF_CH70xx != 0) {
    1015. 

  1015. 		 if(temp & EnableCHYPbPr) {
    1016. 

  1016. 		    tempbx |= SetCRT2ToCHYPbPr;
    1017. 

  1017. 		 }
    1018. 

  1018. 	      }
    1019. 

  1019. 	   }
    1020. 

  1020. 	}
    1021. 

  1021. 

  1022. #endif  /* SIS315H */
    1023. 

  1023. 

  1024.         if(!(SiS_Pr->SiS_VBType & VB_SISVGA2)) {
    1025. 

  1025. 	   tempbx &= ~(SetCRT2ToRAMDAC);
    1026. 

  1026. 	}
    1027. 

  1027. 

  1028. 	if(SiS_Pr->SiS_VBType & VB_SISVB) {
    1029. 

  1029. 	   temp = SetCRT2ToSVIDEO   |
    1030. 

  1030. 		  SetCRT2ToAVIDEO   |
    1031. 

  1031. 		  SetCRT2ToSCART    |
    1032. 

  1032. 		  SetCRT2ToLCDA     |
    1033. 

  1033. 		  SetCRT2ToLCD      |
    1034. 

  1034. 		  SetCRT2ToRAMDAC   |
    1035. 

  1035. 		  SetCRT2ToHiVision |
    1036. 

  1036. 		  SetCRT2ToYPbPr525750;
    1037. 

  1037. 	} else {
    1038. 

  1038. 	   if(SiS_Pr->ChipType >= SIS_315H) {
    1039. 

  1039. 	      if(SiS_Pr->SiS_IF_DEF_CH70xx != 0) {
    1040. 

  1040. 		 temp = SetCRT2ToAVIDEO |
    1041. 

  1041. 		        SetCRT2ToSVIDEO |
    1042. 

  1042. 		        SetCRT2ToSCART  |
    1043. 

  1043. 		        SetCRT2ToLCDA   |
    1044. 

  1044. 		        SetCRT2ToLCD    |
    1045. 

  1045. 		        SetCRT2ToCHYPbPr;
    1046. 

  1046. 	      } else {
    1047. 

  1047. 		 temp = SetCRT2ToLCDA   |
    1048. 

  1048. 		        SetCRT2ToLCD;
    1049. 

  1049. 	      }
    1050. 

  1050. 	   } else {
    1051. 

  1051. 	      if(SiS_Pr->SiS_IF_DEF_CH70xx != 0) {
    1052. 

  1052. 		 temp = SetCRT2ToTV | SetCRT2ToLCD;
    1053. 

  1053. 	      } else {
    1054. 

  1054. 		 temp = SetCRT2ToLCD;
    1055. 

  1055. 	      }
    1056. 

  1056. 	   }
    1057. 

  1057. 	}
    1058. 

  1058. 

  1059. 	if(!(tempbx & temp)) {
    1060. 

  1060. 	   tempax = DisableCRT2Display;
    1061. 

  1061. 	   tempbx = 0;
    1062. 

  1062. 	}
    1063. 

  1063. 

  1064. 	if(SiS_Pr->SiS_VBType & VB_SISVB) {
    1065. 

  1065. 

  1066. 	   unsigned short clearmask = ( DriverMode |
    1067. 

  1067. 				DisableCRT2Display |
    1068. 

  1068. 				LoadDACFlag 	   |
    1069. 

  1069. 				SetNotSimuMode 	   |
    1070. 

  1070. 				SetInSlaveMode 	   |
    1071. 

  1071. 				SetPALTV 	   |
    1072. 

  1072. 				SwitchCRT2	   |
    1073. 

  1073. 				SetSimuScanMode );
    1074. 

  1074. 

  1075. 	   if(tempbx & SetCRT2ToLCDA)        tempbx &= (clearmask | SetCRT2ToLCDA);
    1076. 

  1076. 	   if(tempbx & SetCRT2ToRAMDAC)      tempbx &= (clearmask | SetCRT2ToRAMDAC);
    1077. 

  1077. 	   if(tempbx & SetCRT2ToLCD)         tempbx &= (clearmask | SetCRT2ToLCD);
    1078. 

  1078. 	   if(tempbx & SetCRT2ToSCART)       tempbx &= (clearmask | SetCRT2ToSCART);
    1079. 

  1079. 	   if(tempbx & SetCRT2ToHiVision)    tempbx &= (clearmask | SetCRT2ToHiVision);
    1080. 

  1080. 	   if(tempbx & SetCRT2ToYPbPr525750) tempbx &= (clearmask | SetCRT2ToYPbPr525750);
    1081. 

  1081. 

  1082. 	} else {
    1083. 

  1083. 

  1084. 	   if(SiS_Pr->ChipType >= SIS_315H) {
    1085. 

  1085. 	      if(tempbx & SetCRT2ToLCDA) {
    1086. 

  1086. 		 tempbx &= (0xFF00|SwitchCRT2|SetSimuScanMode);
    1087. 

  1087. 	      }
    1088. 

  1088. 	   }
    1089. 

  1089. 	   if(SiS_Pr->SiS_IF_DEF_CH70xx != 0) {
    1090. 

  1090. 	      if(tempbx & SetCRT2ToTV) {
    1091. 

  1091. 		 tempbx &= (0xFF00|SetCRT2ToTV|SwitchCRT2|SetSimuScanMode);
    1092. 

  1092. 	      }
    1093. 

  1093. 	   }
    1094. 

  1094. 	   if(tempbx & SetCRT2ToLCD) {
    1095. 

  1095. 	      tempbx &= (0xFF00|SetCRT2ToLCD|SwitchCRT2|SetSimuScanMode);
    1096. 

  1096. 	   }
    1097. 

  1097. 	   if(SiS_Pr->ChipType >= SIS_315H) {
    1098. 

  1098. 	      if(tempbx & SetCRT2ToLCDA) {
    1099. 

  1099. 	         tempbx |= SetCRT2ToLCD;
    1100. 

  1100. 	      }
    1101. 

  1101. 	   }
    1102. 

  1102. 

  1103. 	}
    1104. 

  1104. 

  1105. 	if(tempax & DisableCRT2Display) {
    1106. 

  1106. 	   if(!(tempbx & (SwitchCRT2 | SetSimuScanMode))) {
    1107. 

  1107. 	      tempbx = SetSimuScanMode | DisableCRT2Display;
    1108. 

  1108. 	   }
    1109. 

  1109. 	}
    1110. 

  1110. 

  1111. 	if(!(tempbx & DriverMode)) tempbx |= SetSimuScanMode;
    1112. 

  1112. 

  1113. 	/* LVDS/CHRONTEL (LCD/TV) and 301BDH (LCD) can only be slave in 8bpp modes */
    1114. 

  1114. 	if(SiS_Pr->SiS_ModeType <= ModeVGA) {
    1115. 

  1115. 	   if( (SiS_Pr->SiS_IF_DEF_LVDS == 1) ||
    1116. 

  1116. 	       ((SiS_Pr->SiS_VBType & VB_NoLCD) && (tempbx & SetCRT2ToLCD)) ) {
    1117. 

  1117. 	      modeflag &= (~CRT2Mode);
    1118. 

  1118. 	   }
    1119. 

  1119. 	}
    1120. 

  1120. 

  1121. 	if(!(tempbx & SetSimuScanMode)) {
    1122. 

  1122. 	   if(tempbx & SwitchCRT2) {
    1123. 

  1123. 	      if((!(modeflag & CRT2Mode)) && (checkcrt2mode)) {
    1124. 

  1124. 		 if(resinfo != SIS_RI_1600x1200) {
    1125. 

  1125. 		    tempbx |= SetSimuScanMode;
    1126. 

  1126. 		 }
    1127. 

  1127.               }
    1128. 

  1128. 	   } else {
    1129. 

  1129. 	      if(SiS_BridgeIsEnabled(SiS_Pr)) {
    1130. 

  1130. 		 if(!(tempbx & DriverMode)) {
    1131. 

  1131. 		    if(SiS_BridgeInSlavemode(SiS_Pr)) {
    1132. 

  1132. 		       tempbx |= SetSimuScanMode;
    1133. 

  1133. 		    }
    1134. 

  1134. 		 }
    1135. 

  1135. 	      }
    1136. 

  1136. 	   }
    1137. 

  1137. 	}
    1138. 

  1138. 

  1139. 	if(!(tempbx & DisableCRT2Display)) {
    1140. 

  1140. 	   if(tempbx & DriverMode) {
    1141. 

  1141. 	      if(tempbx & SetSimuScanMode) {
    1142. 

  1142. 		 if((!(modeflag & CRT2Mode)) && (checkcrt2mode)) {
    1143. 

  1143. 		    if(resinfo != SIS_RI_1600x1200) {
    1144. 

  1144. 		       tempbx |= SetInSlaveMode;
    1145. 

  1145. 		    }
    1146. 

  1146. 		 }
    1147. 

  1147. 	      }
    1148. 

  1148. 	   } else {
    1149. 

  1149. 	      tempbx |= SetInSlaveMode;
    1150. 

  1150. 	   }
    1151. 

  1151. 	}
    1152. 

  1152. 

  1153.    }
    1154. 

  1154. 

  1155.    SiS_Pr->SiS_VBInfo = tempbx;
    1156. 

  1156. 

  1157. #ifdef SIS300
    1158. 

  1158.    if(SiS_Pr->ChipType == SIS_630) {
    1159. 

  1159.       SiS_SetChrontelGPIO(SiS_Pr, SiS_Pr->SiS_VBInfo);
    1160. 

  1160.    }
    1161. 

  1161. #endif
    1162. 

  1162. 

  1163. #ifdef SIS_LINUX_KERNEL
    1164. 

  1164. #if 0
    1165. 

  1165.    printk(KERN_DEBUG "sisfb: (init301: VBInfo= 0x%04x, SetFlag=0x%04x)\n",
    1166. 

  1166.       SiS_Pr->SiS_VBInfo, SiS_Pr->SiS_SetFlag);
    1167. 

  1167. #endif
    1168. 

  1168. #endif
    1169. 

  1169. #ifdef SIS_XORG_XF86
    1170. 

  1170. #ifdef TWDEBUG
    1171. 

  1171.    xf86DrvMsg(0, X_PROBED, "(init301: VBInfo=0x%04x, SetFlag=0x%04x)\n",
    1172. 

  1172.       SiS_Pr->SiS_VBInfo, SiS_Pr->SiS_SetFlag);
    1173. 

  1173. #endif
    1174. 

  1174. #endif
    1175. 

  1175. }
    1176. 

  1176. 

  1177. /*********************************************/
    1178. 

  1178. /*           DETERMINE YPbPr MODE            */
    1179. 

  1179. /*********************************************/
    1180. 

  1180. 

  1181. void
    1182. 

  1182. SiS_SetYPbPr(struct SiS_Private *SiS_Pr)
    1183. 

  1183. {
    1184. 

  1184. 

  1185.    unsigned char temp;
    1186. 

  1186. 

  1187.    /* Note: This variable is only used on 30xLV systems.
    1188. 

  1188.     * CR38 has a different meaning on LVDS/CH7019 systems.
    1189. 

  1189.     * On 661 and later, these bits moved to CR35.
    1190. 

  1190.     *
    1191. 

  1191.     * On 301, 301B, only HiVision 1080i is supported.
    1192. 

  1192.     * On 30xLV, 301C, only YPbPr 1080i is supported.
    1193. 

  1193.     */
    1194. 

  1194. 

  1195.    SiS_Pr->SiS_YPbPr = 0;
    1196. 

  1196.    if(SiS_Pr->ChipType >= SIS_661) return;
    1197. 

  1197. 

  1198.    if(SiS_Pr->SiS_VBType) {
    1199. 

  1199.       if(SiS_Pr->SiS_VBInfo & SetCRT2ToHiVision) {
    1200. 

  1200. 	 SiS_Pr->SiS_YPbPr = YPbPrHiVision;
    1201. 

  1201.       }
    1202. 

  1202.    }
    1203. 

  1203. 

  1204.    if(SiS_Pr->ChipType >= SIS_315H) {
    1205. 

  1205.       if(SiS_Pr->SiS_VBType & VB_SISYPBPR) {
    1206. 

  1206. 	 temp = SiS_GetReg(SiS_Pr->SiS_P3d4,0x38);
    1207. 

  1207. 	 if(temp & 0x08) {
    1208. 

  1208. 	    switch((temp >> 4)) {
    1209. 

  1209. 	    case 0x00: SiS_Pr->SiS_YPbPr = YPbPr525i;     break;
    1210. 

  1210. 	    case 0x01: SiS_Pr->SiS_YPbPr = YPbPr525p;     break;
    1211. 

  1211. 	    case 0x02: SiS_Pr->SiS_YPbPr = YPbPr750p;     break;
    1212. 

  1212. 	    case 0x03: SiS_Pr->SiS_YPbPr = YPbPrHiVision; break;
    1213. 

  1213. 	    }
    1214. 

  1214. 	 }
    1215. 

  1215.       }
    1216. 

  1216.    }
    1217. 

  1217. 

  1218. }
    1219. 

  1219. 

  1220. /*********************************************/
    1221. 

  1221. /*           DETERMINE TVMode flag           */
    1222. 

  1222. /*********************************************/
    1223. 

  1223. 

  1224. void
    1225. 

  1225. SiS_SetTVMode(struct SiS_Private *SiS_Pr, unsigned short ModeNo, unsigned short ModeIdIndex)
    1226. 

  1226. {
    1227. 

  1227.    unsigned char  *ROMAddr = SiS_Pr->VirtualRomBase;
    1228. 

  1228.    unsigned short temp, temp1, resinfo = 0, romindex = 0;
    1229. 

  1229.    unsigned char  OutputSelect = *SiS_Pr->pSiS_OutputSelect;
    1230. 

  1230. 

  1231.    SiS_Pr->SiS_TVMode = 0;
    1232. 

  1232. 

  1233.    if(!(SiS_Pr->SiS_VBInfo & SetCRT2ToTV)) return;
    1234. 

  1234.    if(SiS_Pr->UseCustomMode) return;
    1235. 

  1235. 

  1236.    if(ModeNo > 0x13) {
    1237. 

  1237.       resinfo = SiS_Pr->SiS_EModeIDTable[ModeIdIndex].Ext_RESINFO;
    1238. 

  1238.    }
    1239. 

  1239. 

  1240.    if(SiS_Pr->ChipType < SIS_661) {
    1241. 

  1241. 

  1242.       if(SiS_Pr->SiS_VBInfo & SetPALTV) SiS_Pr->SiS_TVMode |= TVSetPAL;
    1243. 

  1243. 

  1244.       if(SiS_Pr->SiS_VBType & VB_SISVB) {
    1245. 

  1245. 	 temp = 0;
    1246. 

  1246. 	 if((SiS_Pr->ChipType == SIS_630) ||
    1247. 

  1247. 	    (SiS_Pr->ChipType == SIS_730)) {
    1248. 

  1248. 	    temp = 0x35;
    1249. 

  1249. 	    romindex = 0xfe;
    1250. 

  1250. 	 } else if(SiS_Pr->ChipType >= SIS_315H) {
    1251. 

  1251. 	    temp = 0x38;
    1252. 

  1252. 	    if(SiS_Pr->ChipType < XGI_20) {
    1253. 

  1253. 	       romindex = 0xf3;
    1254. 

  1254. 	       if(SiS_Pr->ChipType >= SIS_330) romindex = 0x11b;
    1255. 

  1255. 	    }
    1256. 

  1256. 	 }
    1257. 

  1257. 	 if(temp) {
    1258. 

  1258. 	    if(romindex && SiS_Pr->SiS_UseROM && (!(SiS_Pr->SiS_ROMNew))) {
    1259. 

  1259. 	       OutputSelect = ROMAddr[romindex];
    1260. 

  1260. 	       if(!(OutputSelect & EnablePALMN)) {
    1261. 

  1261. 		  SiS_SetRegAND(SiS_Pr->SiS_P3d4,temp,0x3F);
    1262. 

  1262. 	       }
    1263. 

  1263. 	    }
    1264. 

  1264. 	    temp1 = SiS_GetReg(SiS_Pr->SiS_P3d4,temp);
    1265. 

  1265. 	    if(SiS_Pr->SiS_TVMode & TVSetPAL) {
    1266. 

  1266. 	       if(temp1 & EnablePALM) {		/* 0x40 */
    1267. 

  1267. 		  SiS_Pr->SiS_TVMode |= TVSetPALM;
    1268. 

  1268. 		  SiS_Pr->SiS_TVMode &= ~TVSetPAL;
    1269. 

  1269. 	       } else if(temp1 & EnablePALN) {	/* 0x80 */
    1270. 

  1270. 		  SiS_Pr->SiS_TVMode |= TVSetPALN;
    1271. 

  1271. 	       }
    1272. 

  1272. 	    } else {
    1273. 

  1273. 	       if(temp1 & EnableNTSCJ) {	/* 0x40 */
    1274. 

  1274. 		  SiS_Pr->SiS_TVMode |= TVSetNTSCJ;
    1275. 

  1275. 	       }
    1276. 

  1276. 	    }
    1277. 

  1277. 	 }
    1278. 

  1278. 	 /* Translate HiVision/YPbPr to our new flags */
    1279. 

  1279. 	 if(SiS_Pr->SiS_VBInfo & SetCRT2ToHiVision) {
    1280. 

  1280. 	    if(SiS_Pr->SiS_YPbPr == YPbPr750p)          SiS_Pr->SiS_TVMode |= TVSetYPbPr750p;
    1281. 

  1281. 	    else if(SiS_Pr->SiS_YPbPr == YPbPr525p)     SiS_Pr->SiS_TVMode |= TVSetYPbPr525p;
    1282. 

  1282. 	    else if(SiS_Pr->SiS_YPbPr == YPbPrHiVision) SiS_Pr->SiS_TVMode |= TVSetHiVision;
    1283. 

  1283. 	    else				        SiS_Pr->SiS_TVMode |= TVSetYPbPr525i;
    1284. 

  1284. 	    if(SiS_Pr->SiS_TVMode & (TVSetYPbPr750p | TVSetYPbPr525p | TVSetYPbPr525i)) {
    1285. 

  1285. 	       SiS_Pr->SiS_VBInfo &= ~SetCRT2ToHiVision;
    1286. 

  1286. 	       SiS_Pr->SiS_VBInfo |= SetCRT2ToYPbPr525750;
    1287. 

  1287. 	    } else if(SiS_Pr->SiS_TVMode & TVSetHiVision) {
    1288. 

  1288. 	       SiS_Pr->SiS_TVMode |= TVSetPAL;
    1289. 

  1289. 	    }
    1290. 

  1290. 	 }
    1291. 

  1291.       } else if(SiS_Pr->SiS_IF_DEF_CH70xx != 0) {
    1292. 

  1292. 	 if(SiS_Pr->SiS_CHOverScan) {
    1293. 

  1293. 	    if(SiS_Pr->SiS_IF_DEF_CH70xx == 1) {
    1294. 

  1294. 	       temp = SiS_GetReg(SiS_Pr->SiS_P3d4,0x35);
    1295. 

  1295. 	       if((temp & TVOverScan) || (SiS_Pr->SiS_CHOverScan == 1)) {
    1296. 

  1296. 		  SiS_Pr->SiS_TVMode |= TVSetCHOverScan;
    1297. 

  1297. 	       }
    1298. 

  1298. 	    } else if(SiS_Pr->SiS_IF_DEF_CH70xx == 2) {
    1299. 

  1299. 	       temp = SiS_GetReg(SiS_Pr->SiS_P3d4,0x79);
    1300. 

  1300. 	       if((temp & 0x80) || (SiS_Pr->SiS_CHOverScan == 1)) {
    1301. 

  1301. 		  SiS_Pr->SiS_TVMode |= TVSetCHOverScan;
    1302. 

  1302. 	       }
    1303. 

  1303. 	    }
    1304. 

  1304. 	    if(SiS_Pr->SiS_CHSOverScan) {
    1305. 

  1305. 	       SiS_Pr->SiS_TVMode |= TVSetCHOverScan;
    1306. 

  1306. 	    }
    1307. 

  1307. 	 }
    1308. 

  1308. 	 if(SiS_Pr->SiS_IF_DEF_CH70xx == 2) {
    1309. 

  1309. 	    temp = SiS_GetReg(SiS_Pr->SiS_P3d4,0x38);
    1310. 

  1310. 	    if(SiS_Pr->SiS_TVMode & TVSetPAL) {
    1311. 

  1311. 	       if(temp & EnablePALM)      SiS_Pr->SiS_TVMode |= TVSetPALM;
    1312. 

  1312. 	       else if(temp & EnablePALN) SiS_Pr->SiS_TVMode |= TVSetPALN;
    1313. 

  1313. 	    } else {
    1314. 

  1314. 	       if(temp & EnableNTSCJ) {
    1315. 

  1315. 		  SiS_Pr->SiS_TVMode |= TVSetNTSCJ;
    1316. 

  1316. 	       }
    1317. 

  1317. 	    }
    1318. 

  1318. 	 }
    1319. 

  1319.       }
    1320. 

  1320. 

  1321.    } else {  /* 661 and later */
    1322. 

  1322. 

  1323.       temp1 = SiS_GetReg(SiS_Pr->SiS_P3d4,0x35);
    1324. 

  1324.       if(temp1 & 0x01) {
    1325. 

  1325. 	 SiS_Pr->SiS_TVMode |= TVSetPAL;
    1326. 

  1326. 	 if(temp1 & 0x08) {
    1327. 

  1327. 	    SiS_Pr->SiS_TVMode |= TVSetPALN;
    1328. 

  1328. 	 } else if(temp1 & 0x04) {
    1329. 

  1329. 	    if(SiS_Pr->SiS_VBType & VB_SISVB) {
    1330. 

  1330. 	       SiS_Pr->SiS_TVMode &= ~TVSetPAL;
    1331. 

  1331. 	    }
    1332. 

  1332. 	    SiS_Pr->SiS_TVMode |= TVSetPALM;
    1333. 

  1333. 	 }
    1334. 

  1334.       } else {
    1335. 

  1335. 	 if(temp1 & 0x02) {
    1336. 

  1336. 	    SiS_Pr->SiS_TVMode |= TVSetNTSCJ;
    1337. 

  1337. 	 }
    1338. 

  1338.       }
    1339. 

  1339.       if(SiS_Pr->SiS_IF_DEF_CH70xx == 2) {
    1340. 

  1340. 	 if(SiS_Pr->SiS_CHOverScan) {
    1341. 

  1341. 	    if((temp1 & 0x10) || (SiS_Pr->SiS_CHOverScan == 1)) {
    1342. 

  1342. 	       SiS_Pr->SiS_TVMode |= TVSetCHOverScan;
    1343. 

  1343. 	    }
    1344. 

  1344. 	 }
    1345. 

  1345.       }
    1346. 

  1346.       if(SiS_Pr->SiS_VBType & VB_SISVB) {
    1347. 

  1347. 	 if(SiS_Pr->SiS_VBInfo & SetCRT2ToYPbPr525750) {
    1348. 

  1348. 	    temp1 &= 0xe0;
    1349. 

  1349. 	    if(temp1 == 0x00)      SiS_Pr->SiS_TVMode |= TVSetYPbPr525i;
    1350. 

  1350. 	    else if(temp1 == 0x20) SiS_Pr->SiS_TVMode |= TVSetYPbPr525p;
    1351. 

  1351. 	    else if(temp1 == 0x40) SiS_Pr->SiS_TVMode |= TVSetYPbPr750p;
    1352. 

  1352. 	 } else if(SiS_Pr->SiS_VBInfo & SetCRT2ToHiVision) {
    1353. 

  1353. 	    SiS_Pr->SiS_TVMode |= (TVSetHiVision | TVSetPAL);
    1354. 

  1354. 	 }
    1355. 

  1355. 	 if(SiS_Pr->SiS_VBInfo & (SetCRT2ToYPbPr525750 | SetCRT2ToHiVision)) {
    1356. 

  1356. 	    if(resinfo == SIS_RI_800x480 || resinfo == SIS_RI_1024x576 || resinfo == SIS_RI_1280x720) {
    1357. 

  1357. 	       SiS_Pr->SiS_TVMode |= TVAspect169;
    1358. 

  1358. 	    } else {
    1359. 

  1359. 	       temp1 = SiS_GetReg(SiS_Pr->SiS_P3d4,0x39);
    1360. 

  1360. 	       if(temp1 & 0x02) {
    1361. 

  1361. 		  if(SiS_Pr->SiS_TVMode & (TVSetYPbPr750p | TVSetHiVision)) {
    1362. 

  1362. 		     SiS_Pr->SiS_TVMode |= TVAspect169;
    1363. 

  1363. 		  } else {
    1364. 

  1364. 		     SiS_Pr->SiS_TVMode |= TVAspect43LB;
    1365. 

  1365. 		  }
    1366. 

  1366. 	       } else {
    1367. 

  1367. 		  SiS_Pr->SiS_TVMode |= TVAspect43;
    1368. 

  1368. 	       }
    1369. 

  1369. 	    }
    1370. 

  1370. 	 }
    1371. 

  1371.       }
    1372. 

  1372.    }
    1373. 

  1373. 

  1374.    if(SiS_Pr->SiS_VBInfo & SetCRT2ToSCART) SiS_Pr->SiS_TVMode |= TVSetPAL;
    1375. 

  1375. 

  1376.    if(SiS_Pr->SiS_VBType & VB_SISVB) {
    1377. 

  1377. 

  1378.       if(SiS_Pr->SiS_VBInfo & SetCRT2ToHiVision) {
    1379. 

  1379. 	 SiS_Pr->SiS_TVMode |= TVSetPAL;
    1380. 

  1380. 	 SiS_Pr->SiS_TVMode &= ~(TVSetPALM | TVSetPALN | TVSetNTSCJ);
    1381. 

  1381.       } else if(SiS_Pr->SiS_VBInfo & SetCRT2ToYPbPr525750) {
    1382. 

  1382. 	 if(SiS_Pr->SiS_TVMode & (TVSetYPbPr525i | TVSetYPbPr525p | TVSetYPbPr750p)) {
    1383. 

  1383. 	    SiS_Pr->SiS_TVMode &= ~(TVSetPAL | TVSetNTSCJ | TVSetPALM | TVSetPALN);
    1384. 

  1384. 	 }
    1385. 

  1385.       }
    1386. 

  1386. 

  1387.       if(SiS_Pr->SiS_VBInfo & SetInSlaveMode) {
    1388. 

  1388. 	 if(!(SiS_Pr->SiS_VBInfo & SetNotSimuMode)) {
    1389. 

  1389. 	    SiS_Pr->SiS_TVMode |= TVSetTVSimuMode;
    1390. 

  1390. 	 }
    1391. 

  1391.       }
    1392. 

  1392. 

  1393.       if(!(SiS_Pr->SiS_TVMode & TVSetPAL)) {
    1394. 

  1394. 	 if(resinfo == SIS_RI_1024x768) {
    1395. 

  1395. 	    if(SiS_Pr->SiS_TVMode & TVSetYPbPr525p) {
    1396. 

  1396. 	       SiS_Pr->SiS_TVMode |= TVSet525p1024;
    1397. 

  1397. 	    } else if(!(SiS_Pr->SiS_TVMode & (TVSetHiVision | TVSetYPbPr750p))) {
    1398. 

  1398. 	       SiS_Pr->SiS_TVMode |= TVSetNTSC1024;
    1399. 

  1399. 	    }
    1400. 

  1400. 	 }
    1401. 

  1401.       }
    1402. 

  1402. 

  1403.       SiS_Pr->SiS_TVMode |= TVRPLLDIV2XO;
    1404. 

  1404.       if((SiS_Pr->SiS_VBInfo & SetCRT2ToHiVision) &&
    1405. 

  1405. 	 (SiS_Pr->SiS_VBInfo & SetInSlaveMode)) {
    1406. 

  1406. 	 SiS_Pr->SiS_TVMode &= ~TVRPLLDIV2XO;
    1407. 

  1407.       } else if(SiS_Pr->SiS_TVMode & (TVSetYPbPr525p | TVSetYPbPr750p)) {
    1408. 

  1408. 	 SiS_Pr->SiS_TVMode &= ~TVRPLLDIV2XO;
    1409. 

  1409.       } else if(!(SiS_Pr->SiS_VBType & VB_SIS30xBLV)) {
    1410. 

  1410. 	 if(SiS_Pr->SiS_TVMode & TVSetTVSimuMode) {
    1411. 

  1411. 	    SiS_Pr->SiS_TVMode &= ~TVRPLLDIV2XO;
    1412. 

  1412. 	 }
    1413. 

  1413.       }
    1414. 

  1414. 

  1415.    }
    1416. 

  1416. 

  1417.    SiS_Pr->SiS_VBInfo &= ~SetPALTV;
    1418. 

  1418. 

  1419. #ifdef SIS_XORG_XF86
    1420. 

  1420. #ifdef TWDEBUG
    1421. 

  1421.    xf86DrvMsg(0, X_INFO, "(init301: TVMode %x, VBInfo %x)\n", SiS_Pr->SiS_TVMode, SiS_Pr->SiS_VBInfo);
    1422. 

  1422. #endif
    1423. 

  1423. #endif
    1424. 

  1424. }
    1425. 

  1425. 

  1426. /*********************************************/
    1427. 

  1427. /*               GET LCD INFO                */
    1428. 

  1428. /*********************************************/
    1429. 

  1429. 

  1430. static unsigned short
    1431. 

  1431. SiS_GetBIOSLCDResInfo(struct SiS_Private *SiS_Pr)
    1432. 

  1432. {
    1433. 

  1433.    unsigned short temp = SiS_Pr->SiS_LCDResInfo;
    1434. 

  1434.    /* Translate my LCDResInfo to BIOS value */
    1435. 

  1435.    switch(temp) {
    1436. 

  1436.    case Panel_1280x768_2: temp = Panel_1280x768;    break;
    1437. 

  1437.    case Panel_1280x800_2: temp = Panel_1280x800;    break;
    1438. 

  1438.    case Panel_1280x854:   temp = Panel661_1280x854; break;
    1439. 

  1439.    }
    1440. 

  1440.    return temp;
    1441. 

  1441. }
    1442. 

  1442. 

  1443. static void
    1444. 

  1444. SiS_GetLCDInfoBIOS(struct SiS_Private *SiS_Pr)
    1445. 

  1445. {
    1446. 

  1446. #ifdef SIS315H
    1447. 

  1447.    unsigned char  *ROMAddr;
    1448. 

  1448.    unsigned short temp;
    1449. 

  1449. 

  1450. #ifdef SIS_XORG_XF86
    1451. 

  1451. #ifdef TWDEBUG
    1452. 

  1452.    xf86DrvMsg(0, X_INFO, "Paneldata driver: [%d %d] [H %d %d] [V %d %d] [C %d 0x%02x 0x%02x]\n",
    1453. 

  1453. 	SiS_Pr->PanelHT, SiS_Pr->PanelVT,
    1454. 

  1454. 	SiS_Pr->PanelHRS, SiS_Pr->PanelHRE,
    1455. 

  1455. 	SiS_Pr->PanelVRS, SiS_Pr->PanelVRE,
    1456. 

  1456. 	SiS_Pr->SiS_VBVCLKData[SiS_Pr->PanelVCLKIdx315].CLOCK,
    1457. 

  1457. 	SiS_Pr->SiS_VBVCLKData[SiS_Pr->PanelVCLKIdx315].Part4_A,
    1458. 

  1458. 	SiS_Pr->SiS_VBVCLKData[SiS_Pr->PanelVCLKIdx315].Part4_B);
    1459. 

  1459. #endif
    1460. 

  1460. #endif
    1461. 

  1461. 

  1462.    if((ROMAddr = GetLCDStructPtr661(SiS_Pr))) {
    1463. 

  1463.       if((temp = SISGETROMW(6)) != SiS_Pr->PanelHT) {
    1464. 

  1464. 	 SiS_Pr->SiS_NeedRomModeData = true;
    1465. 

  1465. 	 SiS_Pr->PanelHT  = temp;
    1466. 

  1466.       }
    1467. 

  1467.       if((temp = SISGETROMW(8)) != SiS_Pr->PanelVT) {
    1468. 

  1468. 	 SiS_Pr->SiS_NeedRomModeData = true;
    1469. 

  1469. 	 SiS_Pr->PanelVT  = temp;
    1470. 

  1470.       }
    1471. 

  1471.       SiS_Pr->PanelHRS = SISGETROMW(10);
    1472. 

  1472.       SiS_Pr->PanelHRE = SISGETROMW(12);
    1473. 

  1473.       SiS_Pr->PanelVRS = SISGETROMW(14);
    1474. 

  1474.       SiS_Pr->PanelVRE = SISGETROMW(16);
    1475. 

  1475.       SiS_Pr->PanelVCLKIdx315 = VCLK_CUSTOM_315;
    1476. 

  1476.       SiS_Pr->SiS_VCLKData[VCLK_CUSTOM_315].CLOCK =
    1477. 

  1477. 	 SiS_Pr->SiS_VBVCLKData[VCLK_CUSTOM_315].CLOCK = (unsigned short)((unsigned char)ROMAddr[18]);
    1478. 

  1478.       SiS_Pr->SiS_VCLKData[VCLK_CUSTOM_315].SR2B =
    1479. 

  1479. 	 SiS_Pr->SiS_VBVCLKData[VCLK_CUSTOM_315].Part4_A = ROMAddr[19];
    1480. 

  1480.       SiS_Pr->SiS_VCLKData[VCLK_CUSTOM_315].SR2C =
    1481. 

  1481. 	 SiS_Pr->SiS_VBVCLKData[VCLK_CUSTOM_315].Part4_B = ROMAddr[20];
    1482. 

  1482. 

  1483. #ifdef SIS_XORG_XF86
    1484. 

  1484. #ifdef TWDEBUG
    1485. 

  1485.       xf86DrvMsg(0, X_INFO, "Paneldata BIOS:  [%d %d] [H %d %d] [V %d %d] [C %d 0x%02x 0x%02x]\n",
    1486. 

  1486. 	SiS_Pr->PanelHT, SiS_Pr->PanelVT,
    1487. 

  1487. 	SiS_Pr->PanelHRS, SiS_Pr->PanelHRE,
    1488. 

  1488. 	SiS_Pr->PanelVRS, SiS_Pr->PanelVRE,
    1489. 

  1489. 	SiS_Pr->SiS_VBVCLKData[SiS_Pr->PanelVCLKIdx315].CLOCK,
    1490. 

  1490. 	SiS_Pr->SiS_VBVCLKData[SiS_Pr->PanelVCLKIdx315].Part4_A,
    1491. 

  1491. 	SiS_Pr->SiS_VBVCLKData[SiS_Pr->PanelVCLKIdx315].Part4_B);
    1492. 

  1492. #endif
    1493. 

  1493. #endif
    1494. 

  1494. 

  1495.    }
    1496. 

  1496. #endif
    1497. 

  1497. }
    1498. 

  1498. 

  1499. static void
    1500. 

  1500. SiS_CheckScaling(struct SiS_Private *SiS_Pr, unsigned short resinfo,
    1501. 

  1501. 			const unsigned char *nonscalingmodes)
    1502. 

  1502. {
    1503. 

  1503.    int i = 0;
    1504. 

  1504.    while(nonscalingmodes[i] != 0xff) {
    1505. 

  1505.       if(nonscalingmodes[i++] == resinfo) {
    1506. 

  1506. 	 if((SiS_Pr->SiS_VBInfo & SetCRT2ToLCD) ||
    1507. 

  1507. 	    (SiS_Pr->UsePanelScaler == -1)) {
    1508. 

  1508. 	    SiS_Pr->SiS_LCDInfo |= DontExpandLCD;
    1509. 

  1509. 	 }
    1510. 

  1510. 	 break;
    1511. 

  1511.       }
    1512. 

  1512.    }
    1513. 

  1513. }
    1514. 

  1514. 

  1515. void
    1516. 

  1516. SiS_GetLCDResInfo(struct SiS_Private *SiS_Pr, unsigned short ModeNo, unsigned short ModeIdIndex)
    1517. 

  1517. {
    1518. 

  1518.   unsigned short temp,modeflag,resinfo=0,modexres=0,modeyres=0;
    1519. 

  1519.   bool panelcanscale = false;
    1520. 

  1520. #ifdef SIS300
    1521. 

  1521.   unsigned char *ROMAddr = SiS_Pr->VirtualRomBase;
    1522. 

  1522.   static const unsigned char SiS300SeriesLCDRes[] =
    1523. 

  1523.           { 0,  1,  2,  3,  7,  4,  5,  8,
    1524. 

  1524. 	    0,  0, 10,  0,  0,  0,  0, 15 };
    1525. 

  1525. #endif
    1526. 

  1526. #ifdef SIS315H
    1527. 

  1527.   unsigned char   *myptr = NULL;
    1528. 

  1528. #endif
    1529. 

  1529. 

  1530.   SiS_Pr->SiS_LCDResInfo  = 0;
    1531. 

  1531.   SiS_Pr->SiS_LCDTypeInfo = 0;
    1532. 

  1532.   SiS_Pr->SiS_LCDInfo     = 0;
    1533. 

  1533.   SiS_Pr->PanelHRS        = 999; /* HSync start */
    1534. 

  1534.   SiS_Pr->PanelHRE        = 999; /* HSync end */
    1535. 

  1535.   SiS_Pr->PanelVRS        = 999; /* VSync start */
    1536. 

  1536.   SiS_Pr->PanelVRE        = 999; /* VSync end */
    1537. 

  1537.   SiS_Pr->SiS_NeedRomModeData = false;
    1538. 

  1538. 

  1539.   /* Alternative 1600x1200@60 timing for 1600x1200 LCDA */
    1540. 

  1540.   SiS_Pr->Alternate1600x1200 = false;
    1541. 

  1541. 

  1542.   if(!(SiS_Pr->SiS_VBInfo & (SetCRT2ToLCD | SetCRT2ToLCDA))) return;
    1543. 

  1543. 

  1544.   modeflag = SiS_GetModeFlag(SiS_Pr, ModeNo, ModeIdIndex);
    1545. 

  1545. 

  1546.   if((ModeNo > 0x13) && (!SiS_Pr->UseCustomMode)) {
    1547. 

  1547.      resinfo = SiS_Pr->SiS_EModeIDTable[ModeIdIndex].Ext_RESINFO;
    1548. 

  1548.      modexres = SiS_Pr->SiS_ModeResInfo[resinfo].HTotal;
    1549. 

  1549.      modeyres = SiS_Pr->SiS_ModeResInfo[resinfo].VTotal;
    1550. 

  1550.   }
    1551. 

  1551. 

  1552.   temp = SiS_GetReg(SiS_Pr->SiS_P3d4,0x36);
    1553. 

  1553. 

  1554.   /* For broken BIOSes: Assume 1024x768 */
    1555. 

  1555.   if(temp == 0) temp = 0x02;
    1556. 

  1556. 

  1557.   if((SiS_Pr->ChipType >= SIS_661) || (SiS_Pr->SiS_ROMNew)) {
    1558. 

  1558.      SiS_Pr->SiS_LCDTypeInfo = (SiS_GetReg(SiS_Pr->SiS_P3d4,0x39) & 0x7c) >> 2;
    1559. 

  1559.   } else if((SiS_Pr->ChipType < SIS_315H) || (SiS_Pr->ChipType >= SIS_661)) {
    1560. 

  1560.      SiS_Pr->SiS_LCDTypeInfo = temp >> 4;
    1561. 

  1561.   } else {
    1562. 

  1562.      SiS_Pr->SiS_LCDTypeInfo = (temp & 0x0F) - 1;
    1563. 

  1563.   }
    1564. 

  1564.   temp &= 0x0f;
    1565. 

  1565. #ifdef SIS300
    1566. 

  1566.   if(SiS_Pr->ChipType < SIS_315H) {
    1567. 

  1567.      /* Very old BIOSes only know 7 sizes (NetVista 2179, 1.01g) */
    1568. 

  1568.      if(SiS_Pr->SiS_VBType & VB_SIS301) {
    1569. 

  1569.         if(temp < 0x0f) temp &= 0x07;
    1570. 

  1570.      }
    1571. 

  1571.      /* Translate 300 series LCDRes to 315 series for unified usage */
    1572. 

  1572.      temp = SiS300SeriesLCDRes[temp];
    1573. 

  1573.   }
    1574. 

  1574. #endif
    1575. 

  1575. 

  1576.   /* Translate to our internal types */
    1577. 

  1577. #ifdef SIS315H
    1578. 

  1578.   if(SiS_Pr->ChipType == SIS_550) {
    1579. 

  1579.      if     (temp == Panel310_1152x768)  temp = Panel_320x240_2; /* Verified working */
    1580. 

  1580.      else if(temp == Panel310_320x240_2) temp = Panel_320x240_2;
    1581. 

  1581.      else if(temp == Panel310_320x240_3) temp = Panel_320x240_3;
    1582. 

  1582.   } else if(SiS_Pr->ChipType >= SIS_661) {
    1583. 

  1583.      if(temp == Panel661_1280x854)       temp = Panel_1280x854;
    1584. 

  1584.   }
    1585. 

  1585. #endif
    1586. 

  1586. 

  1587.   if(SiS_Pr->SiS_VBType & VB_SISLVDS) {		/* SiS LVDS */
    1588. 

  1588.      if(temp == Panel310_1280x768) {
    1589. 

  1589.         temp = Panel_1280x768_2;
    1590. 

  1590.      }
    1591. 

  1591.      if(SiS_Pr->SiS_ROMNew) {
    1592. 

  1592. 	if(temp == Panel661_1280x800) {
    1593. 

  1593. 	   temp = Panel_1280x800_2;
    1594. 

  1594. 	}
    1595. 

  1595.      }
    1596. 

  1596.   }
    1597. 

  1597. 

  1598.   SiS_Pr->SiS_LCDResInfo = temp;
    1599. 

  1599. 

  1600. #ifdef SIS300
    1601. 

  1601.   if(SiS_Pr->SiS_IF_DEF_LVDS == 1) {
    1602. 

  1602.      if(SiS_Pr->SiS_CustomT == CUT_BARCO1366) {
    1603. 

  1603. 	SiS_Pr->SiS_LCDResInfo = Panel_Barco1366;
    1604. 

  1604.      } else if(SiS_Pr->SiS_CustomT == CUT_PANEL848) {
    1605. 

  1605. 	SiS_Pr->SiS_LCDResInfo = Panel_848x480;
    1606. 

  1606.      } else if(SiS_Pr->SiS_CustomT == CUT_PANEL856) {
    1607. 

  1607. 	SiS_Pr->SiS_LCDResInfo = Panel_856x480;
    1608. 

  1608.      }
    1609. 

  1609.   }
    1610. 

  1610. #endif
    1611. 

  1611. 

  1612.   if(SiS_Pr->SiS_VBType & VB_SISVB) {
    1613. 

  1613.      if(SiS_Pr->SiS_LCDResInfo < SiS_Pr->SiS_PanelMin301)
    1614. 

  1614. 	SiS_Pr->SiS_LCDResInfo = SiS_Pr->SiS_PanelMin301;
    1615. 

  1615.   } else {
    1616. 

  1616.      if(SiS_Pr->SiS_LCDResInfo < SiS_Pr->SiS_PanelMinLVDS)
    1617. 

  1617. 	SiS_Pr->SiS_LCDResInfo = SiS_Pr->SiS_PanelMinLVDS;
    1618. 

  1618.   }
    1619. 

  1619. 

  1620.   temp = SiS_GetReg(SiS_Pr->SiS_P3d4,0x37);
    1621. 

  1621.   SiS_Pr->SiS_LCDInfo = temp & ~0x000e;
    1622. 

  1622.   /* Need temp below! */
    1623. 

  1623. 

  1624.   /* These must/can't scale no matter what */
    1625. 

  1625.   switch(SiS_Pr->SiS_LCDResInfo) {
    1626. 

  1626.   case Panel_320x240_1:
    1627. 

  1627.   case Panel_320x240_2:
    1628. 

  1628.   case Panel_320x240_3:
    1629. 

  1629.   case Panel_1280x960:
    1630. 

  1630.       SiS_Pr->SiS_LCDInfo &= ~DontExpandLCD;
    1631. 

  1631.       break;
    1632. 

  1632.   case Panel_640x480:
    1633. 

  1633.       SiS_Pr->SiS_LCDInfo |= DontExpandLCD;
    1634. 

  1634.   }
    1635. 

  1635. 

  1636.   panelcanscale = (bool)(SiS_Pr->SiS_LCDInfo & DontExpandLCD);
    1637. 

  1637. 

  1638.   if(!SiS_Pr->UsePanelScaler)          SiS_Pr->SiS_LCDInfo &= ~DontExpandLCD;
    1639. 

  1639.   else if(SiS_Pr->UsePanelScaler == 1) SiS_Pr->SiS_LCDInfo |= DontExpandLCD;
    1640. 

  1640. 

  1641.   /* Dual link, Pass 1:1 BIOS default, etc. */
    1642. 

  1642. #ifdef SIS315H
    1643. 

  1643.   if(SiS_Pr->ChipType >= SIS_661) {
    1644. 

  1644.      if(SiS_Pr->SiS_LCDInfo & DontExpandLCD) {
    1645. 

  1645. 	if(temp & 0x08) SiS_Pr->SiS_LCDInfo |= LCDPass11;
    1646. 

  1646.      }
    1647. 

  1647.      if(SiS_Pr->SiS_VBType & VB_SISDUALLINK) {
    1648. 

  1648. 	if(SiS_Pr->SiS_ROMNew) {
    1649. 

  1649. 	   if(temp & 0x02) SiS_Pr->SiS_LCDInfo |= LCDDualLink;
    1650. 

  1650. 	} else if((myptr = GetLCDStructPtr661(SiS_Pr))) {
    1651. 

  1651. 	   if(myptr[2] & 0x01) SiS_Pr->SiS_LCDInfo |= LCDDualLink;
    1652. 

  1652. 	}
    1653. 

  1653.      }
    1654. 

  1654.   } else if(SiS_Pr->ChipType >= SIS_315H) {
    1655. 

  1655.      if(SiS_Pr->SiS_LCDInfo & DontExpandLCD) {
    1656. 

  1656. 	if(SiS_GetReg(SiS_Pr->SiS_P3d4,0x39) & 0x01) SiS_Pr->SiS_LCDInfo |= LCDPass11;
    1657. 

  1657.      }
    1658. 

  1658.      if((SiS_Pr->SiS_ROMNew) && (!(SiS_Pr->PanelSelfDetected))) {
    1659. 

  1659. 	SiS_Pr->SiS_LCDInfo &= ~(LCDRGB18Bit);
    1660. 

  1660. 	temp = SiS_GetReg(SiS_Pr->SiS_P3d4,0x35);
    1661. 

  1661. 	if(temp & 0x01) SiS_Pr->SiS_LCDInfo |= LCDRGB18Bit;
    1662. 

  1662. 	if(SiS_Pr->SiS_VBType & VB_SISDUALLINK) {
    1663. 

  1663. 	   if(temp & 0x02) SiS_Pr->SiS_LCDInfo |= LCDDualLink;
    1664. 

  1664. 	}
    1665. 

  1665.      } else if(!(SiS_Pr->SiS_ROMNew)) {
    1666. 

  1666. 	if(SiS_Pr->SiS_VBType & VB_SISDUALLINK) {
    1667. 

  1667. 	   if((SiS_Pr->SiS_CustomT == CUT_CLEVO1024) &&
    1668. 

  1668. 	      (SiS_Pr->SiS_LCDResInfo == Panel_1024x768)) {
    1669. 

  1669. 	      SiS_Pr->SiS_LCDInfo |= LCDDualLink;
    1670. 

  1670. 	   }
    1671. 

  1671. 	   if((SiS_Pr->SiS_LCDResInfo == Panel_1280x1024) ||
    1672. 

  1672. 	      (SiS_Pr->SiS_LCDResInfo == Panel_1400x1050) ||
    1673. 

  1673. 	      (SiS_Pr->SiS_LCDResInfo == Panel_1600x1200) ||
    1674. 

  1674. 	      (SiS_Pr->SiS_LCDResInfo == Panel_1680x1050)) {
    1675. 

  1675. 	      SiS_Pr->SiS_LCDInfo |= LCDDualLink;
    1676. 

  1676. 	   }
    1677. 

  1677. 	}
    1678. 

  1678.      }
    1679. 

  1679.   }
    1680. 

  1680. #endif
    1681. 

  1681. 

  1682.   /* Pass 1:1 */
    1683. 

  1683.   if((SiS_Pr->SiS_IF_DEF_LVDS == 1) || (SiS_Pr->SiS_VBType & VB_NoLCD)) {
    1684. 

  1684.      /* Always center screen on LVDS (if scaling is disabled) */
    1685. 

  1685.      SiS_Pr->SiS_LCDInfo &= ~LCDPass11;
    1686. 

  1686.   } else if(SiS_Pr->SiS_VBType & VB_SISVB) {
    1687. 

  1687.      if(SiS_Pr->SiS_VBType & VB_SISLVDS) {
    1688. 

  1688. 	/* Always center screen on SiS LVDS (if scaling is disabled) */
    1689. 

  1689. 	SiS_Pr->SiS_LCDInfo &= ~LCDPass11;
    1690. 

  1690.      } else {
    1691. 

  1691. 	/* By default, pass 1:1 on SiS TMDS (if scaling is supported) */
    1692. 

  1692. 	if(panelcanscale)             SiS_Pr->SiS_LCDInfo |= LCDPass11;
    1693. 

  1693. 	if(SiS_Pr->CenterScreen == 1) SiS_Pr->SiS_LCDInfo &= ~LCDPass11;
    1694. 

  1694.      }
    1695. 

  1695.   }
    1696. 

  1696. 

  1697.   SiS_Pr->PanelVCLKIdx300 = VCLK65_300;
    1698. 

  1698.   SiS_Pr->PanelVCLKIdx315 = VCLK108_2_315;
    1699. 

  1699. 

  1700.   switch(SiS_Pr->SiS_LCDResInfo) {
    1701. 

  1701.      case Panel_320x240_1:
    1702. 

  1702.      case Panel_320x240_2:
    1703. 

  1703.      case Panel_320x240_3:  SiS_Pr->PanelXRes =  640; SiS_Pr->PanelYRes =  480;
    1704. 

  1704. 			    SiS_Pr->PanelVRS  =   24; SiS_Pr->PanelVRE  =    3;
    1705. 

  1705. 			    SiS_Pr->PanelVCLKIdx300 = VCLK28;
    1706. 

  1706. 			    SiS_Pr->PanelVCLKIdx315 = VCLK28;
    1707. 

  1707. 			    break;
    1708. 

  1708.      case Panel_640x480:    SiS_Pr->PanelXRes =  640; SiS_Pr->PanelYRes =  480;
    1709. 

  1709. 						      SiS_Pr->PanelVRE  =    3;
    1710. 

  1710. 			    SiS_Pr->PanelVCLKIdx300 = VCLK28;
    1711. 

  1711. 			    SiS_Pr->PanelVCLKIdx315 = VCLK28;
    1712. 

  1712. 			    break;
    1713. 

  1713.      case Panel_800x600:    SiS_Pr->PanelXRes =  800; SiS_Pr->PanelYRes =  600;
    1714. 

  1714.      			    SiS_Pr->PanelHT   = 1056; SiS_Pr->PanelVT   =  628;
    1715. 

  1715. 			    SiS_Pr->PanelHRS  =   40; SiS_Pr->PanelHRE  =  128;
    1716. 

  1716. 			    SiS_Pr->PanelVRS  =    1; SiS_Pr->PanelVRE  =    4;
    1717. 

  1717. 			    SiS_Pr->PanelVCLKIdx300 = VCLK40;
    1718. 

  1718. 			    SiS_Pr->PanelVCLKIdx315 = VCLK40;
    1719. 

  1719. 			    break;
    1720. 

  1720.      case Panel_1024x600:   SiS_Pr->PanelXRes = 1024; SiS_Pr->PanelYRes =  600;
    1721. 

  1721. 			    SiS_Pr->PanelHT   = 1344; SiS_Pr->PanelVT   =  800;
    1722. 

  1722. 			    SiS_Pr->PanelHRS  =   24; SiS_Pr->PanelHRE  =  136;
    1723. 

  1723. 			    SiS_Pr->PanelVRS  =    2 /* 88 */ ; SiS_Pr->PanelVRE  =    6;
    1724. 

  1724. 			    SiS_Pr->PanelVCLKIdx300 = VCLK65_300;
    1725. 

  1725. 			    SiS_Pr->PanelVCLKIdx315 = VCLK65_315;
    1726. 

  1726. 			    break;
    1727. 

  1727.      case Panel_1024x768:   SiS_Pr->PanelXRes = 1024; SiS_Pr->PanelYRes =  768;
    1728. 

  1728. 			    SiS_Pr->PanelHT   = 1344; SiS_Pr->PanelVT   =  806;
    1729. 

  1729. 			    SiS_Pr->PanelHRS  =   24; SiS_Pr->PanelHRE  =  136;
    1730. 

  1730. 			    SiS_P…
    1731.