forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
955 lines
25 KiB
955 lines
25 KiB
// SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause) |
|
/* |
|
* sisusb - usb kernel driver for SiS315(E) based USB2VGA dongles |
|
* |
|
* Display mode initializing code |
|
* |
|
* Copyright (C) 2001-2005 by Thomas Winischhofer, Vienna, Austria |
|
* |
|
* If distributed as part of the Linux kernel, this code is licensed under the |
|
* terms of the GPL v2. |
|
* |
|
* Otherwise, the following license terms apply: |
|
* |
|
* * Redistribution and use in source and binary forms, with or without |
|
* * modification, are permitted provided that the following conditions |
|
* * are met: |
|
* * 1) Redistributions of source code must retain the above copyright |
|
* * notice, this list of conditions and the following disclaimer. |
|
* * 2) Redistributions in binary form must reproduce the above copyright |
|
* * notice, this list of conditions and the following disclaimer in the |
|
* * documentation and/or other materials provided with the distribution. |
|
* * 3) The name of the author may not be used to endorse or promote products |
|
* * derived from this software without specific prior written permission. |
|
* * |
|
* * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
|
* * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
|
* * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
|
* * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
|
* * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|
* * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
|
* * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
|
* * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
|
* * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
|
* * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|
* |
|
* Author: Thomas Winischhofer <[email protected]> |
|
* |
|
*/ |
|
|
|
#include <linux/module.h> |
|
#include <linux/kernel.h> |
|
#include <linux/errno.h> |
|
#include <linux/poll.h> |
|
#include <linux/spinlock.h> |
|
|
|
#include "sisusb.h" |
|
#include "sisusb_init.h" |
|
#include "sisusb_tables.h" |
|
|
|
/*********************************************/ |
|
/* POINTER INITIALIZATION */ |
|
/*********************************************/ |
|
|
|
static void SiSUSB_InitPtr(struct SiS_Private *SiS_Pr) |
|
{ |
|
SiS_Pr->SiS_ModeResInfo = SiSUSB_ModeResInfo; |
|
SiS_Pr->SiS_StandTable = SiSUSB_StandTable; |
|
|
|
SiS_Pr->SiS_SModeIDTable = SiSUSB_SModeIDTable; |
|
SiS_Pr->SiS_EModeIDTable = SiSUSB_EModeIDTable; |
|
SiS_Pr->SiS_RefIndex = SiSUSB_RefIndex; |
|
SiS_Pr->SiS_CRT1Table = SiSUSB_CRT1Table; |
|
|
|
SiS_Pr->SiS_VCLKData = SiSUSB_VCLKData; |
|
} |
|
|
|
/*********************************************/ |
|
/* HELPER: SetReg, GetReg */ |
|
/*********************************************/ |
|
|
|
static void |
|
SiS_SetReg(struct SiS_Private *SiS_Pr, unsigned long port, |
|
unsigned short index, unsigned short data) |
|
{ |
|
sisusb_setidxreg(SiS_Pr->sisusb, port, index, data); |
|
} |
|
|
|
static void |
|
SiS_SetRegByte(struct SiS_Private *SiS_Pr, unsigned long port, |
|
unsigned short data) |
|
{ |
|
sisusb_setreg(SiS_Pr->sisusb, port, data); |
|
} |
|
|
|
static unsigned char |
|
SiS_GetReg(struct SiS_Private *SiS_Pr, unsigned long port, unsigned short index) |
|
{ |
|
u8 data; |
|
|
|
sisusb_getidxreg(SiS_Pr->sisusb, port, index, &data); |
|
|
|
return data; |
|
} |
|
|
|
static unsigned char |
|
SiS_GetRegByte(struct SiS_Private *SiS_Pr, unsigned long port) |
|
{ |
|
u8 data; |
|
|
|
sisusb_getreg(SiS_Pr->sisusb, port, &data); |
|
|
|
return data; |
|
} |
|
|
|
static void |
|
SiS_SetRegANDOR(struct SiS_Private *SiS_Pr, unsigned long port, |
|
unsigned short index, unsigned short DataAND, |
|
unsigned short DataOR) |
|
{ |
|
sisusb_setidxregandor(SiS_Pr->sisusb, port, index, DataAND, DataOR); |
|
} |
|
|
|
static void |
|
SiS_SetRegAND(struct SiS_Private *SiS_Pr, unsigned long port, |
|
unsigned short index, unsigned short DataAND) |
|
{ |
|
sisusb_setidxregand(SiS_Pr->sisusb, port, index, DataAND); |
|
} |
|
|
|
static void |
|
SiS_SetRegOR(struct SiS_Private *SiS_Pr, unsigned long port, |
|
unsigned short index, unsigned short DataOR) |
|
{ |
|
sisusb_setidxregor(SiS_Pr->sisusb, port, index, DataOR); |
|
} |
|
|
|
/*********************************************/ |
|
/* HELPER: DisplayOn, DisplayOff */ |
|
/*********************************************/ |
|
|
|
static void SiS_DisplayOn(struct SiS_Private *SiS_Pr) |
|
{ |
|
SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3c4, 0x01, 0xDF); |
|
} |
|
|
|
/*********************************************/ |
|
/* HELPER: Init Port Addresses */ |
|
/*********************************************/ |
|
|
|
static void SiSUSBRegInit(struct SiS_Private *SiS_Pr, unsigned long BaseAddr) |
|
{ |
|
SiS_Pr->SiS_P3c4 = BaseAddr + 0x14; |
|
SiS_Pr->SiS_P3d4 = BaseAddr + 0x24; |
|
SiS_Pr->SiS_P3c0 = BaseAddr + 0x10; |
|
SiS_Pr->SiS_P3ce = BaseAddr + 0x1e; |
|
SiS_Pr->SiS_P3c2 = BaseAddr + 0x12; |
|
SiS_Pr->SiS_P3ca = BaseAddr + 0x1a; |
|
SiS_Pr->SiS_P3c6 = BaseAddr + 0x16; |
|
SiS_Pr->SiS_P3c7 = BaseAddr + 0x17; |
|
SiS_Pr->SiS_P3c8 = BaseAddr + 0x18; |
|
SiS_Pr->SiS_P3c9 = BaseAddr + 0x19; |
|
SiS_Pr->SiS_P3cb = BaseAddr + 0x1b; |
|
SiS_Pr->SiS_P3cc = BaseAddr + 0x1c; |
|
SiS_Pr->SiS_P3cd = BaseAddr + 0x1d; |
|
SiS_Pr->SiS_P3da = BaseAddr + 0x2a; |
|
SiS_Pr->SiS_Part1Port = BaseAddr + SIS_CRT2_PORT_04; |
|
} |
|
|
|
/*********************************************/ |
|
/* HELPER: GetSysFlags */ |
|
/*********************************************/ |
|
|
|
static void SiS_GetSysFlags(struct SiS_Private *SiS_Pr) |
|
{ |
|
SiS_Pr->SiS_MyCR63 = 0x63; |
|
} |
|
|
|
/*********************************************/ |
|
/* HELPER: Init PCI & Engines */ |
|
/*********************************************/ |
|
|
|
static void SiSInitPCIetc(struct SiS_Private *SiS_Pr) |
|
{ |
|
SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x20, 0xa1); |
|
/* - Enable 2D (0x40) |
|
* - Enable 3D (0x02) |
|
* - Enable 3D vertex command fetch (0x10) |
|
* - Enable 3D command parser (0x08) |
|
* - Enable 3D G/L transformation engine (0x80) |
|
*/ |
|
SiS_SetRegOR(SiS_Pr, SiS_Pr->SiS_P3c4, 0x1E, 0xDA); |
|
} |
|
|
|
/*********************************************/ |
|
/* HELPER: SET SEGMENT REGISTERS */ |
|
/*********************************************/ |
|
|
|
static void SiS_SetSegRegLower(struct SiS_Private *SiS_Pr, unsigned short value) |
|
{ |
|
unsigned short temp; |
|
|
|
value &= 0x00ff; |
|
temp = SiS_GetRegByte(SiS_Pr, SiS_Pr->SiS_P3cb) & 0xf0; |
|
temp |= (value >> 4); |
|
SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3cb, temp); |
|
temp = SiS_GetRegByte(SiS_Pr, SiS_Pr->SiS_P3cd) & 0xf0; |
|
temp |= (value & 0x0f); |
|
SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3cd, temp); |
|
} |
|
|
|
static void SiS_SetSegRegUpper(struct SiS_Private *SiS_Pr, unsigned short value) |
|
{ |
|
unsigned short temp; |
|
|
|
value &= 0x00ff; |
|
temp = SiS_GetRegByte(SiS_Pr, SiS_Pr->SiS_P3cb) & 0x0f; |
|
temp |= (value & 0xf0); |
|
SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3cb, temp); |
|
temp = SiS_GetRegByte(SiS_Pr, SiS_Pr->SiS_P3cd) & 0x0f; |
|
temp |= (value << 4); |
|
SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3cd, temp); |
|
} |
|
|
|
static void SiS_SetSegmentReg(struct SiS_Private *SiS_Pr, unsigned short value) |
|
{ |
|
SiS_SetSegRegLower(SiS_Pr, value); |
|
SiS_SetSegRegUpper(SiS_Pr, value); |
|
} |
|
|
|
static void SiS_ResetSegmentReg(struct SiS_Private *SiS_Pr) |
|
{ |
|
SiS_SetSegmentReg(SiS_Pr, 0); |
|
} |
|
|
|
static void |
|
SiS_SetSegmentRegOver(struct SiS_Private *SiS_Pr, unsigned short value) |
|
{ |
|
unsigned short temp = value >> 8; |
|
|
|
temp &= 0x07; |
|
temp |= (temp << 4); |
|
SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x1d, temp); |
|
SiS_SetSegmentReg(SiS_Pr, value); |
|
} |
|
|
|
static void SiS_ResetSegmentRegOver(struct SiS_Private *SiS_Pr) |
|
{ |
|
SiS_SetSegmentRegOver(SiS_Pr, 0); |
|
} |
|
|
|
static void SiS_ResetSegmentRegisters(struct SiS_Private *SiS_Pr) |
|
{ |
|
SiS_ResetSegmentReg(SiS_Pr); |
|
SiS_ResetSegmentRegOver(SiS_Pr); |
|
} |
|
|
|
/*********************************************/ |
|
/* HELPER: SearchModeID */ |
|
/*********************************************/ |
|
|
|
static int |
|
SiS_SearchModeID(struct SiS_Private *SiS_Pr, unsigned short *ModeNo, |
|
unsigned short *ModeIdIndex) |
|
{ |
|
if ((*ModeNo) <= 0x13) { |
|
|
|
if ((*ModeNo) != 0x03) |
|
return 0; |
|
|
|
(*ModeIdIndex) = 0; |
|
|
|
} else { |
|
|
|
for (*ModeIdIndex = 0;; (*ModeIdIndex)++) { |
|
|
|
if (SiS_Pr->SiS_EModeIDTable[*ModeIdIndex].Ext_ModeID == |
|
(*ModeNo)) |
|
break; |
|
|
|
if (SiS_Pr->SiS_EModeIDTable[*ModeIdIndex].Ext_ModeID == |
|
0xFF) |
|
return 0; |
|
} |
|
|
|
} |
|
|
|
return 1; |
|
} |
|
|
|
/*********************************************/ |
|
/* HELPER: ENABLE CRT1 */ |
|
/*********************************************/ |
|
|
|
static void SiS_HandleCRT1(struct SiS_Private *SiS_Pr) |
|
{ |
|
/* Enable CRT1 gating */ |
|
SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3d4, SiS_Pr->SiS_MyCR63, 0xbf); |
|
} |
|
|
|
/*********************************************/ |
|
/* HELPER: GetColorDepth */ |
|
/*********************************************/ |
|
|
|
static unsigned short |
|
SiS_GetColorDepth(struct SiS_Private *SiS_Pr, unsigned short ModeNo, |
|
unsigned short ModeIdIndex) |
|
{ |
|
static const unsigned short ColorDepth[6] = { 1, 2, 4, 4, 6, 8 }; |
|
unsigned short modeflag; |
|
short index; |
|
|
|
if (ModeNo <= 0x13) { |
|
modeflag = SiS_Pr->SiS_SModeIDTable[ModeIdIndex].St_ModeFlag; |
|
} else { |
|
modeflag = SiS_Pr->SiS_EModeIDTable[ModeIdIndex].Ext_ModeFlag; |
|
} |
|
|
|
index = (modeflag & ModeTypeMask) - ModeEGA; |
|
if (index < 0) |
|
index = 0; |
|
return ColorDepth[index]; |
|
} |
|
|
|
/*********************************************/ |
|
/* HELPER: GetOffset */ |
|
/*********************************************/ |
|
|
|
static unsigned short |
|
SiS_GetOffset(struct SiS_Private *SiS_Pr, unsigned short ModeNo, |
|
unsigned short ModeIdIndex, unsigned short rrti) |
|
{ |
|
unsigned short xres, temp, colordepth, infoflag; |
|
|
|
infoflag = SiS_Pr->SiS_RefIndex[rrti].Ext_InfoFlag; |
|
xres = SiS_Pr->SiS_RefIndex[rrti].XRes; |
|
|
|
colordepth = SiS_GetColorDepth(SiS_Pr, ModeNo, ModeIdIndex); |
|
|
|
temp = xres / 16; |
|
|
|
if (infoflag & InterlaceMode) |
|
temp <<= 1; |
|
|
|
temp *= colordepth; |
|
|
|
if (xres % 16) |
|
temp += (colordepth >> 1); |
|
|
|
return temp; |
|
} |
|
|
|
/*********************************************/ |
|
/* SEQ */ |
|
/*********************************************/ |
|
|
|
static void |
|
SiS_SetSeqRegs(struct SiS_Private *SiS_Pr, unsigned short StandTableIndex) |
|
{ |
|
unsigned char SRdata; |
|
int i; |
|
|
|
SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x00, 0x03); |
|
|
|
SRdata = SiS_Pr->SiS_StandTable[StandTableIndex].SR[0] | 0x20; |
|
SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x01, SRdata); |
|
|
|
for (i = 2; i <= 4; i++) { |
|
SRdata = SiS_Pr->SiS_StandTable[StandTableIndex].SR[i - 1]; |
|
SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, i, SRdata); |
|
} |
|
} |
|
|
|
/*********************************************/ |
|
/* MISC */ |
|
/*********************************************/ |
|
|
|
static void |
|
SiS_SetMiscRegs(struct SiS_Private *SiS_Pr, unsigned short StandTableIndex) |
|
{ |
|
unsigned char Miscdata = SiS_Pr->SiS_StandTable[StandTableIndex].MISC; |
|
|
|
SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3c2, Miscdata); |
|
} |
|
|
|
/*********************************************/ |
|
/* CRTC */ |
|
/*********************************************/ |
|
|
|
static void |
|
SiS_SetCRTCRegs(struct SiS_Private *SiS_Pr, unsigned short StandTableIndex) |
|
{ |
|
unsigned char CRTCdata; |
|
unsigned short i; |
|
|
|
SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3d4, 0x11, 0x7f); |
|
|
|
for (i = 0; i <= 0x18; i++) { |
|
CRTCdata = SiS_Pr->SiS_StandTable[StandTableIndex].CRTC[i]; |
|
SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3d4, i, CRTCdata); |
|
} |
|
} |
|
|
|
/*********************************************/ |
|
/* ATT */ |
|
/*********************************************/ |
|
|
|
static void |
|
SiS_SetATTRegs(struct SiS_Private *SiS_Pr, unsigned short StandTableIndex) |
|
{ |
|
unsigned char ARdata; |
|
unsigned short i; |
|
|
|
for (i = 0; i <= 0x13; i++) { |
|
ARdata = SiS_Pr->SiS_StandTable[StandTableIndex].ATTR[i]; |
|
SiS_GetRegByte(SiS_Pr, SiS_Pr->SiS_P3da); |
|
SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3c0, i); |
|
SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3c0, ARdata); |
|
} |
|
SiS_GetRegByte(SiS_Pr, SiS_Pr->SiS_P3da); |
|
SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3c0, 0x14); |
|
SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3c0, 0x00); |
|
|
|
SiS_GetRegByte(SiS_Pr, SiS_Pr->SiS_P3da); |
|
SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3c0, 0x20); |
|
SiS_GetRegByte(SiS_Pr, SiS_Pr->SiS_P3da); |
|
} |
|
|
|
/*********************************************/ |
|
/* GRC */ |
|
/*********************************************/ |
|
|
|
static void |
|
SiS_SetGRCRegs(struct SiS_Private *SiS_Pr, unsigned short StandTableIndex) |
|
{ |
|
unsigned char GRdata; |
|
unsigned short i; |
|
|
|
for (i = 0; i <= 0x08; i++) { |
|
GRdata = SiS_Pr->SiS_StandTable[StandTableIndex].GRC[i]; |
|
SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3ce, i, GRdata); |
|
} |
|
|
|
if (SiS_Pr->SiS_ModeType > ModeVGA) { |
|
/* 256 color disable */ |
|
SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3ce, 0x05, 0xBF); |
|
} |
|
} |
|
|
|
/*********************************************/ |
|
/* CLEAR EXTENDED REGISTERS */ |
|
/*********************************************/ |
|
|
|
static void SiS_ClearExt1Regs(struct SiS_Private *SiS_Pr, unsigned short ModeNo) |
|
{ |
|
int i; |
|
|
|
for (i = 0x0A; i <= 0x0E; i++) { |
|
SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, i, 0x00); |
|
} |
|
|
|
SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3c4, 0x37, 0xFE); |
|
} |
|
|
|
/*********************************************/ |
|
/* Get rate index */ |
|
/*********************************************/ |
|
|
|
static unsigned short |
|
SiS_GetRatePtr(struct SiS_Private *SiS_Pr, unsigned short ModeNo, |
|
unsigned short ModeIdIndex) |
|
{ |
|
unsigned short rrti, i, index, temp; |
|
|
|
if (ModeNo <= 0x13) |
|
return 0xFFFF; |
|
|
|
index = SiS_GetReg(SiS_Pr, SiS_Pr->SiS_P3d4, 0x33) & 0x0F; |
|
if (index > 0) |
|
index--; |
|
|
|
rrti = SiS_Pr->SiS_EModeIDTable[ModeIdIndex].REFindex; |
|
ModeNo = SiS_Pr->SiS_RefIndex[rrti].ModeID; |
|
|
|
i = 0; |
|
do { |
|
if (SiS_Pr->SiS_RefIndex[rrti + i].ModeID != ModeNo) |
|
break; |
|
|
|
temp = |
|
SiS_Pr->SiS_RefIndex[rrti + i].Ext_InfoFlag & ModeTypeMask; |
|
if (temp < SiS_Pr->SiS_ModeType) |
|
break; |
|
|
|
i++; |
|
index--; |
|
} while (index != 0xFFFF); |
|
|
|
i--; |
|
|
|
return (rrti + i); |
|
} |
|
|
|
/*********************************************/ |
|
/* SYNC */ |
|
/*********************************************/ |
|
|
|
static void SiS_SetCRT1Sync(struct SiS_Private *SiS_Pr, unsigned short rrti) |
|
{ |
|
unsigned short sync = SiS_Pr->SiS_RefIndex[rrti].Ext_InfoFlag >> 8; |
|
sync &= 0xC0; |
|
sync |= 0x2f; |
|
SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3c2, sync); |
|
} |
|
|
|
/*********************************************/ |
|
/* CRTC/2 */ |
|
/*********************************************/ |
|
|
|
static void |
|
SiS_SetCRT1CRTC(struct SiS_Private *SiS_Pr, unsigned short ModeNo, |
|
unsigned short ModeIdIndex, unsigned short rrti) |
|
{ |
|
unsigned char index; |
|
unsigned short temp, i, j, modeflag; |
|
|
|
SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3d4, 0x11, 0x7f); |
|
|
|
modeflag = SiS_Pr->SiS_EModeIDTable[ModeIdIndex].Ext_ModeFlag; |
|
|
|
index = SiS_Pr->SiS_RefIndex[rrti].Ext_CRT1CRTC; |
|
|
|
for (i = 0, j = 0; i <= 7; i++, j++) { |
|
SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3d4, j, |
|
SiS_Pr->SiS_CRT1Table[index].CR[i]); |
|
} |
|
for (j = 0x10; i <= 10; i++, j++) { |
|
SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3d4, j, |
|
SiS_Pr->SiS_CRT1Table[index].CR[i]); |
|
} |
|
for (j = 0x15; i <= 12; i++, j++) { |
|
SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3d4, j, |
|
SiS_Pr->SiS_CRT1Table[index].CR[i]); |
|
} |
|
for (j = 0x0A; i <= 15; i++, j++) { |
|
SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, j, |
|
SiS_Pr->SiS_CRT1Table[index].CR[i]); |
|
} |
|
|
|
temp = SiS_Pr->SiS_CRT1Table[index].CR[16] & 0xE0; |
|
SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x0E, temp); |
|
|
|
temp = ((SiS_Pr->SiS_CRT1Table[index].CR[16]) & 0x01) << 5; |
|
if (modeflag & DoubleScanMode) |
|
temp |= 0x80; |
|
SiS_SetRegANDOR(SiS_Pr, SiS_Pr->SiS_P3d4, 0x09, 0x5F, temp); |
|
|
|
if (SiS_Pr->SiS_ModeType > ModeVGA) |
|
SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3d4, 0x14, 0x4F); |
|
} |
|
|
|
/*********************************************/ |
|
/* OFFSET & PITCH */ |
|
/*********************************************/ |
|
/* (partly overruled by SetPitch() in XF86) */ |
|
/*********************************************/ |
|
|
|
static void |
|
SiS_SetCRT1Offset(struct SiS_Private *SiS_Pr, unsigned short ModeNo, |
|
unsigned short ModeIdIndex, unsigned short rrti) |
|
{ |
|
unsigned short du = SiS_GetOffset(SiS_Pr, ModeNo, ModeIdIndex, rrti); |
|
unsigned short infoflag = SiS_Pr->SiS_RefIndex[rrti].Ext_InfoFlag; |
|
unsigned short temp; |
|
|
|
temp = (du >> 8) & 0x0f; |
|
SiS_SetRegANDOR(SiS_Pr, SiS_Pr->SiS_P3c4, 0x0E, 0xF0, temp); |
|
|
|
SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3d4, 0x13, (du & 0xFF)); |
|
|
|
if (infoflag & InterlaceMode) |
|
du >>= 1; |
|
|
|
du <<= 5; |
|
temp = (du >> 8) & 0xff; |
|
if (du & 0xff) |
|
temp++; |
|
temp++; |
|
SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x10, temp); |
|
} |
|
|
|
/*********************************************/ |
|
/* VCLK */ |
|
/*********************************************/ |
|
|
|
static void |
|
SiS_SetCRT1VCLK(struct SiS_Private *SiS_Pr, unsigned short ModeNo, |
|
unsigned short rrti) |
|
{ |
|
unsigned short index = SiS_Pr->SiS_RefIndex[rrti].Ext_CRTVCLK; |
|
unsigned short clka = SiS_Pr->SiS_VCLKData[index].SR2B; |
|
unsigned short clkb = SiS_Pr->SiS_VCLKData[index].SR2C; |
|
|
|
SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3c4, 0x31, 0xCF); |
|
|
|
SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x2B, clka); |
|
SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x2C, clkb); |
|
SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x2D, 0x01); |
|
} |
|
|
|
/*********************************************/ |
|
/* FIFO */ |
|
/*********************************************/ |
|
|
|
static void |
|
SiS_SetCRT1FIFO_310(struct SiS_Private *SiS_Pr, unsigned short ModeNo, |
|
unsigned short mi) |
|
{ |
|
unsigned short modeflag = SiS_Pr->SiS_EModeIDTable[mi].Ext_ModeFlag; |
|
|
|
/* disable auto-threshold */ |
|
SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3c4, 0x3D, 0xFE); |
|
|
|
SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x08, 0xAE); |
|
SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3c4, 0x09, 0xF0); |
|
|
|
if (ModeNo <= 0x13) |
|
return; |
|
|
|
if ((!(modeflag & DoubleScanMode)) || (!(modeflag & HalfDCLK))) { |
|
SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x08, 0x34); |
|
SiS_SetRegOR(SiS_Pr, SiS_Pr->SiS_P3c4, 0x3D, 0x01); |
|
} |
|
} |
|
|
|
/*********************************************/ |
|
/* MODE REGISTERS */ |
|
/*********************************************/ |
|
|
|
static void |
|
SiS_SetVCLKState(struct SiS_Private *SiS_Pr, unsigned short ModeNo, |
|
unsigned short rrti) |
|
{ |
|
unsigned short data = 0, VCLK = 0, index = 0; |
|
|
|
if (ModeNo > 0x13) { |
|
index = SiS_Pr->SiS_RefIndex[rrti].Ext_CRTVCLK; |
|
VCLK = SiS_Pr->SiS_VCLKData[index].CLOCK; |
|
} |
|
|
|
if (VCLK >= 166) |
|
data |= 0x0c; |
|
SiS_SetRegANDOR(SiS_Pr, SiS_Pr->SiS_P3c4, 0x32, 0xf3, data); |
|
|
|
if (VCLK >= 166) |
|
SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3c4, 0x1f, 0xe7); |
|
|
|
/* DAC speed */ |
|
data = 0x03; |
|
if (VCLK >= 260) |
|
data = 0x00; |
|
else if (VCLK >= 160) |
|
data = 0x01; |
|
else if (VCLK >= 135) |
|
data = 0x02; |
|
|
|
SiS_SetRegANDOR(SiS_Pr, SiS_Pr->SiS_P3c4, 0x07, 0xF8, data); |
|
} |
|
|
|
static void |
|
SiS_SetCRT1ModeRegs(struct SiS_Private *SiS_Pr, unsigned short ModeNo, |
|
unsigned short ModeIdIndex, unsigned short rrti) |
|
{ |
|
unsigned short data, infoflag = 0, modeflag; |
|
|
|
if (ModeNo <= 0x13) |
|
modeflag = SiS_Pr->SiS_SModeIDTable[ModeIdIndex].St_ModeFlag; |
|
else { |
|
modeflag = SiS_Pr->SiS_EModeIDTable[ModeIdIndex].Ext_ModeFlag; |
|
infoflag = SiS_Pr->SiS_RefIndex[rrti].Ext_InfoFlag; |
|
} |
|
|
|
/* Disable DPMS */ |
|
SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3c4, 0x1F, 0x3F); |
|
|
|
data = 0; |
|
if (ModeNo > 0x13) { |
|
if (SiS_Pr->SiS_ModeType > ModeEGA) { |
|
data |= 0x02; |
|
data |= ((SiS_Pr->SiS_ModeType - ModeVGA) << 2); |
|
} |
|
if (infoflag & InterlaceMode) |
|
data |= 0x20; |
|
} |
|
SiS_SetRegANDOR(SiS_Pr, SiS_Pr->SiS_P3c4, 0x06, 0xC0, data); |
|
|
|
data = 0; |
|
if (infoflag & InterlaceMode) { |
|
/* data = (Hsync / 8) - ((Htotal / 8) / 2) + 3 */ |
|
unsigned short hrs = |
|
(SiS_GetReg(SiS_Pr, SiS_Pr->SiS_P3d4, 0x04) | |
|
((SiS_GetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x0b) & 0xc0) << 2)) |
|
- 3; |
|
unsigned short hto = |
|
(SiS_GetReg(SiS_Pr, SiS_Pr->SiS_P3d4, 0x00) | |
|
((SiS_GetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x0b) & 0x03) << 8)) |
|
+ 5; |
|
data = hrs - (hto >> 1) + 3; |
|
} |
|
SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3d4, 0x19, (data & 0xFF)); |
|
SiS_SetRegANDOR(SiS_Pr, SiS_Pr->SiS_P3d4, 0x1a, 0xFC, (data >> 8)); |
|
|
|
if (modeflag & HalfDCLK) |
|
SiS_SetRegOR(SiS_Pr, SiS_Pr->SiS_P3c4, 0x01, 0x08); |
|
|
|
data = 0; |
|
if (modeflag & LineCompareOff) |
|
data = 0x08; |
|
SiS_SetRegANDOR(SiS_Pr, SiS_Pr->SiS_P3c4, 0x0F, 0xB7, data); |
|
|
|
if ((SiS_Pr->SiS_ModeType == ModeEGA) && (ModeNo > 0x13)) |
|
SiS_SetRegOR(SiS_Pr, SiS_Pr->SiS_P3c4, 0x0F, 0x40); |
|
|
|
SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3c4, 0x31, 0xfb); |
|
|
|
data = 0x60; |
|
if (SiS_Pr->SiS_ModeType != ModeText) { |
|
data ^= 0x60; |
|
if (SiS_Pr->SiS_ModeType != ModeEGA) |
|
data ^= 0xA0; |
|
} |
|
SiS_SetRegANDOR(SiS_Pr, SiS_Pr->SiS_P3c4, 0x21, 0x1F, data); |
|
|
|
SiS_SetVCLKState(SiS_Pr, ModeNo, rrti); |
|
|
|
if (SiS_GetReg(SiS_Pr, SiS_Pr->SiS_P3d4, 0x31) & 0x40) |
|
SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3d4, 0x52, 0x2c); |
|
else |
|
SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3d4, 0x52, 0x6c); |
|
} |
|
|
|
/*********************************************/ |
|
/* LOAD DAC */ |
|
/*********************************************/ |
|
|
|
static void |
|
SiS_WriteDAC(struct SiS_Private *SiS_Pr, unsigned long DACData, |
|
unsigned short shiftflag, unsigned short dl, unsigned short ah, |
|
unsigned short al, unsigned short dh) |
|
{ |
|
unsigned short d1, d2, d3; |
|
|
|
switch (dl) { |
|
case 0: |
|
d1 = dh; |
|
d2 = ah; |
|
d3 = al; |
|
break; |
|
case 1: |
|
d1 = ah; |
|
d2 = al; |
|
d3 = dh; |
|
break; |
|
default: |
|
d1 = al; |
|
d2 = dh; |
|
d3 = ah; |
|
} |
|
SiS_SetRegByte(SiS_Pr, DACData, (d1 << shiftflag)); |
|
SiS_SetRegByte(SiS_Pr, DACData, (d2 << shiftflag)); |
|
SiS_SetRegByte(SiS_Pr, DACData, (d3 << shiftflag)); |
|
} |
|
|
|
static void |
|
SiS_LoadDAC(struct SiS_Private *SiS_Pr, unsigned short ModeNo, |
|
unsigned short mi) |
|
{ |
|
unsigned short data, data2, time, i, j, k, m, n, o; |
|
unsigned short si, di, bx, sf; |
|
unsigned long DACAddr, DACData; |
|
const unsigned char *table = NULL; |
|
|
|
if (ModeNo < 0x13) |
|
data = SiS_Pr->SiS_SModeIDTable[mi].St_ModeFlag; |
|
else |
|
data = SiS_Pr->SiS_EModeIDTable[mi].Ext_ModeFlag; |
|
|
|
data &= DACInfoFlag; |
|
|
|
j = time = 64; |
|
if (data == 0x00) |
|
table = SiS_MDA_DAC; |
|
else if (data == 0x08) |
|
table = SiS_CGA_DAC; |
|
else if (data == 0x10) |
|
table = SiS_EGA_DAC; |
|
else { |
|
j = 16; |
|
time = 256; |
|
table = SiS_VGA_DAC; |
|
} |
|
|
|
DACAddr = SiS_Pr->SiS_P3c8; |
|
DACData = SiS_Pr->SiS_P3c9; |
|
sf = 0; |
|
SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3c6, 0xFF); |
|
|
|
SiS_SetRegByte(SiS_Pr, DACAddr, 0x00); |
|
|
|
for (i = 0; i < j; i++) { |
|
data = table[i]; |
|
for (k = 0; k < 3; k++) { |
|
data2 = 0; |
|
if (data & 0x01) |
|
data2 += 0x2A; |
|
if (data & 0x02) |
|
data2 += 0x15; |
|
SiS_SetRegByte(SiS_Pr, DACData, (data2 << sf)); |
|
data >>= 2; |
|
} |
|
} |
|
|
|
if (time == 256) { |
|
for (i = 16; i < 32; i++) { |
|
data = table[i] << sf; |
|
for (k = 0; k < 3; k++) |
|
SiS_SetRegByte(SiS_Pr, DACData, data); |
|
} |
|
si = 32; |
|
for (m = 0; m < 9; m++) { |
|
di = si; |
|
bx = si + 4; |
|
for (n = 0; n < 3; n++) { |
|
for (o = 0; o < 5; o++) { |
|
SiS_WriteDAC(SiS_Pr, DACData, sf, n, |
|
table[di], table[bx], |
|
table[si]); |
|
si++; |
|
} |
|
si -= 2; |
|
for (o = 0; o < 3; o++) { |
|
SiS_WriteDAC(SiS_Pr, DACData, sf, n, |
|
table[di], table[si], |
|
table[bx]); |
|
si--; |
|
} |
|
} |
|
si += 5; |
|
} |
|
} |
|
} |
|
|
|
/*********************************************/ |
|
/* SET CRT1 REGISTER GROUP */ |
|
/*********************************************/ |
|
|
|
static void |
|
SiS_SetCRT1Group(struct SiS_Private *SiS_Pr, unsigned short ModeNo, |
|
unsigned short ModeIdIndex) |
|
{ |
|
unsigned short StandTableIndex, rrti; |
|
|
|
SiS_Pr->SiS_CRT1Mode = ModeNo; |
|
|
|
if (ModeNo <= 0x13) |
|
StandTableIndex = 0; |
|
else |
|
StandTableIndex = 1; |
|
|
|
SiS_ResetSegmentRegisters(SiS_Pr); |
|
SiS_SetSeqRegs(SiS_Pr, StandTableIndex); |
|
SiS_SetMiscRegs(SiS_Pr, StandTableIndex); |
|
SiS_SetCRTCRegs(SiS_Pr, StandTableIndex); |
|
SiS_SetATTRegs(SiS_Pr, StandTableIndex); |
|
SiS_SetGRCRegs(SiS_Pr, StandTableIndex); |
|
SiS_ClearExt1Regs(SiS_Pr, ModeNo); |
|
|
|
rrti = SiS_GetRatePtr(SiS_Pr, ModeNo, ModeIdIndex); |
|
|
|
if (rrti != 0xFFFF) { |
|
SiS_SetCRT1Sync(SiS_Pr, rrti); |
|
SiS_SetCRT1CRTC(SiS_Pr, ModeNo, ModeIdIndex, rrti); |
|
SiS_SetCRT1Offset(SiS_Pr, ModeNo, ModeIdIndex, rrti); |
|
SiS_SetCRT1VCLK(SiS_Pr, ModeNo, rrti); |
|
} |
|
|
|
SiS_SetCRT1FIFO_310(SiS_Pr, ModeNo, ModeIdIndex); |
|
|
|
SiS_SetCRT1ModeRegs(SiS_Pr, ModeNo, ModeIdIndex, rrti); |
|
|
|
SiS_LoadDAC(SiS_Pr, ModeNo, ModeIdIndex); |
|
|
|
SiS_DisplayOn(SiS_Pr); |
|
} |
|
|
|
/*********************************************/ |
|
/* SiSSetMode() */ |
|
/*********************************************/ |
|
|
|
int SiSUSBSetMode(struct SiS_Private *SiS_Pr, unsigned short ModeNo) |
|
{ |
|
unsigned short ModeIdIndex; |
|
unsigned long BaseAddr = SiS_Pr->IOAddress; |
|
|
|
SiSUSB_InitPtr(SiS_Pr); |
|
SiSUSBRegInit(SiS_Pr, BaseAddr); |
|
SiS_GetSysFlags(SiS_Pr); |
|
|
|
if (!(SiS_SearchModeID(SiS_Pr, &ModeNo, &ModeIdIndex))) |
|
return 0; |
|
|
|
SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x05, 0x86); |
|
|
|
SiSInitPCIetc(SiS_Pr); |
|
|
|
ModeNo &= 0x7f; |
|
|
|
SiS_Pr->SiS_ModeType = |
|
SiS_Pr->SiS_EModeIDTable[ModeIdIndex].Ext_ModeFlag & ModeTypeMask; |
|
|
|
SiS_Pr->SiS_SetFlag = LowModeTests; |
|
|
|
/* Set mode on CRT1 */ |
|
SiS_SetCRT1Group(SiS_Pr, ModeNo, ModeIdIndex); |
|
|
|
SiS_HandleCRT1(SiS_Pr); |
|
|
|
SiS_DisplayOn(SiS_Pr); |
|
SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3c6, 0xFF); |
|
|
|
/* Store mode number */ |
|
SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3d4, 0x34, ModeNo); |
|
|
|
return 1; |
|
} |
|
|
|
int SiSUSBSetVESAMode(struct SiS_Private *SiS_Pr, unsigned short VModeNo) |
|
{ |
|
unsigned short ModeNo = 0; |
|
int i; |
|
|
|
SiSUSB_InitPtr(SiS_Pr); |
|
|
|
if (VModeNo == 0x03) { |
|
|
|
ModeNo = 0x03; |
|
|
|
} else { |
|
|
|
i = 0; |
|
do { |
|
|
|
if (SiS_Pr->SiS_EModeIDTable[i].Ext_VESAID == VModeNo) { |
|
ModeNo = SiS_Pr->SiS_EModeIDTable[i].Ext_ModeID; |
|
break; |
|
} |
|
|
|
} while (SiS_Pr->SiS_EModeIDTable[i++].Ext_ModeID != 0xff); |
|
|
|
} |
|
|
|
if (!ModeNo) |
|
return 0; |
|
|
|
return SiSUSBSetMode(SiS_Pr, ModeNo); |
|
}
|
|
|