Loading...
1// SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause)
2/*
3 * sisusb - usb kernel driver for SiS315(E) based USB2VGA dongles
4 *
5 * Display mode initializing code
6 *
7 * Copyright (C) 2001-2005 by Thomas Winischhofer, Vienna, Austria
8 *
9 * If distributed as part of the Linux kernel, this code is licensed under the
10 * terms of the GPL v2.
11 *
12 * Otherwise, the following license terms apply:
13 *
14 * * Redistribution and use in source and binary forms, with or without
15 * * modification, are permitted provided that the following conditions
16 * * are met:
17 * * 1) Redistributions of source code must retain the above copyright
18 * * notice, this list of conditions and the following disclaimer.
19 * * 2) Redistributions in binary form must reproduce the above copyright
20 * * notice, this list of conditions and the following disclaimer in the
21 * * documentation and/or other materials provided with the distribution.
22 * * 3) The name of the author may not be used to endorse or promote products
23 * * derived from this software without specific prior written permission.
24 * *
25 * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
26 * * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
27 * * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
28 * * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
29 * * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
30 * * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
31 * * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
32 * * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
33 * * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
34 * * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
35 *
36 * Author: Thomas Winischhofer <thomas@winischhofer.net>
37 *
38 */
39
40#include <linux/module.h>
41#include <linux/kernel.h>
42#include <linux/errno.h>
43#include <linux/poll.h>
44#include <linux/spinlock.h>
45
46#include "sisusb.h"
47#include "sisusb_init.h"
48#include "sisusb_tables.h"
49
50/*********************************************/
51/* POINTER INITIALIZATION */
52/*********************************************/
53
54static void SiSUSB_InitPtr(struct SiS_Private *SiS_Pr)
55{
56 SiS_Pr->SiS_ModeResInfo = SiSUSB_ModeResInfo;
57 SiS_Pr->SiS_StandTable = SiSUSB_StandTable;
58
59 SiS_Pr->SiS_SModeIDTable = SiSUSB_SModeIDTable;
60 SiS_Pr->SiS_EModeIDTable = SiSUSB_EModeIDTable;
61 SiS_Pr->SiS_RefIndex = SiSUSB_RefIndex;
62 SiS_Pr->SiS_CRT1Table = SiSUSB_CRT1Table;
63
64 SiS_Pr->SiS_VCLKData = SiSUSB_VCLKData;
65}
66
67/*********************************************/
68/* HELPER: SetReg, GetReg */
69/*********************************************/
70
71static void
72SiS_SetReg(struct SiS_Private *SiS_Pr, unsigned long port,
73 unsigned short index, unsigned short data)
74{
75 sisusb_setidxreg(SiS_Pr->sisusb, port, index, data);
76}
77
78static void
79SiS_SetRegByte(struct SiS_Private *SiS_Pr, unsigned long port,
80 unsigned short data)
81{
82 sisusb_setreg(SiS_Pr->sisusb, port, data);
83}
84
85static unsigned char
86SiS_GetReg(struct SiS_Private *SiS_Pr, unsigned long port, unsigned short index)
87{
88 u8 data;
89
90 sisusb_getidxreg(SiS_Pr->sisusb, port, index, &data);
91
92 return data;
93}
94
95static unsigned char
96SiS_GetRegByte(struct SiS_Private *SiS_Pr, unsigned long port)
97{
98 u8 data;
99
100 sisusb_getreg(SiS_Pr->sisusb, port, &data);
101
102 return data;
103}
104
105static void
106SiS_SetRegANDOR(struct SiS_Private *SiS_Pr, unsigned long port,
107 unsigned short index, unsigned short DataAND,
108 unsigned short DataOR)
109{
110 sisusb_setidxregandor(SiS_Pr->sisusb, port, index, DataAND, DataOR);
111}
112
113static void
114SiS_SetRegAND(struct SiS_Private *SiS_Pr, unsigned long port,
115 unsigned short index, unsigned short DataAND)
116{
117 sisusb_setidxregand(SiS_Pr->sisusb, port, index, DataAND);
118}
119
120static void
121SiS_SetRegOR(struct SiS_Private *SiS_Pr, unsigned long port,
122 unsigned short index, unsigned short DataOR)
123{
124 sisusb_setidxregor(SiS_Pr->sisusb, port, index, DataOR);
125}
126
127/*********************************************/
128/* HELPER: DisplayOn, DisplayOff */
129/*********************************************/
130
131static void SiS_DisplayOn(struct SiS_Private *SiS_Pr)
132{
133 SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3c4, 0x01, 0xDF);
134}
135
136/*********************************************/
137/* HELPER: Init Port Addresses */
138/*********************************************/
139
140static void SiSUSBRegInit(struct SiS_Private *SiS_Pr, unsigned long BaseAddr)
141{
142 SiS_Pr->SiS_P3c4 = BaseAddr + 0x14;
143 SiS_Pr->SiS_P3d4 = BaseAddr + 0x24;
144 SiS_Pr->SiS_P3c0 = BaseAddr + 0x10;
145 SiS_Pr->SiS_P3ce = BaseAddr + 0x1e;
146 SiS_Pr->SiS_P3c2 = BaseAddr + 0x12;
147 SiS_Pr->SiS_P3ca = BaseAddr + 0x1a;
148 SiS_Pr->SiS_P3c6 = BaseAddr + 0x16;
149 SiS_Pr->SiS_P3c7 = BaseAddr + 0x17;
150 SiS_Pr->SiS_P3c8 = BaseAddr + 0x18;
151 SiS_Pr->SiS_P3c9 = BaseAddr + 0x19;
152 SiS_Pr->SiS_P3cb = BaseAddr + 0x1b;
153 SiS_Pr->SiS_P3cc = BaseAddr + 0x1c;
154 SiS_Pr->SiS_P3cd = BaseAddr + 0x1d;
155 SiS_Pr->SiS_P3da = BaseAddr + 0x2a;
156 SiS_Pr->SiS_Part1Port = BaseAddr + SIS_CRT2_PORT_04;
157}
158
159/*********************************************/
160/* HELPER: GetSysFlags */
161/*********************************************/
162
163static void SiS_GetSysFlags(struct SiS_Private *SiS_Pr)
164{
165 SiS_Pr->SiS_MyCR63 = 0x63;
166}
167
168/*********************************************/
169/* HELPER: Init PCI & Engines */
170/*********************************************/
171
172static void SiSInitPCIetc(struct SiS_Private *SiS_Pr)
173{
174 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x20, 0xa1);
175 /* - Enable 2D (0x40)
176 * - Enable 3D (0x02)
177 * - Enable 3D vertex command fetch (0x10)
178 * - Enable 3D command parser (0x08)
179 * - Enable 3D G/L transformation engine (0x80)
180 */
181 SiS_SetRegOR(SiS_Pr, SiS_Pr->SiS_P3c4, 0x1E, 0xDA);
182}
183
184/*********************************************/
185/* HELPER: SET SEGMENT REGISTERS */
186/*********************************************/
187
188static void SiS_SetSegRegLower(struct SiS_Private *SiS_Pr, unsigned short value)
189{
190 unsigned short temp;
191
192 value &= 0x00ff;
193 temp = SiS_GetRegByte(SiS_Pr, SiS_Pr->SiS_P3cb) & 0xf0;
194 temp |= (value >> 4);
195 SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3cb, temp);
196 temp = SiS_GetRegByte(SiS_Pr, SiS_Pr->SiS_P3cd) & 0xf0;
197 temp |= (value & 0x0f);
198 SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3cd, temp);
199}
200
201static void SiS_SetSegRegUpper(struct SiS_Private *SiS_Pr, unsigned short value)
202{
203 unsigned short temp;
204
205 value &= 0x00ff;
206 temp = SiS_GetRegByte(SiS_Pr, SiS_Pr->SiS_P3cb) & 0x0f;
207 temp |= (value & 0xf0);
208 SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3cb, temp);
209 temp = SiS_GetRegByte(SiS_Pr, SiS_Pr->SiS_P3cd) & 0x0f;
210 temp |= (value << 4);
211 SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3cd, temp);
212}
213
214static void SiS_SetSegmentReg(struct SiS_Private *SiS_Pr, unsigned short value)
215{
216 SiS_SetSegRegLower(SiS_Pr, value);
217 SiS_SetSegRegUpper(SiS_Pr, value);
218}
219
220static void SiS_ResetSegmentReg(struct SiS_Private *SiS_Pr)
221{
222 SiS_SetSegmentReg(SiS_Pr, 0);
223}
224
225static void
226SiS_SetSegmentRegOver(struct SiS_Private *SiS_Pr, unsigned short value)
227{
228 unsigned short temp = value >> 8;
229
230 temp &= 0x07;
231 temp |= (temp << 4);
232 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x1d, temp);
233 SiS_SetSegmentReg(SiS_Pr, value);
234}
235
236static void SiS_ResetSegmentRegOver(struct SiS_Private *SiS_Pr)
237{
238 SiS_SetSegmentRegOver(SiS_Pr, 0);
239}
240
241static void SiS_ResetSegmentRegisters(struct SiS_Private *SiS_Pr)
242{
243 SiS_ResetSegmentReg(SiS_Pr);
244 SiS_ResetSegmentRegOver(SiS_Pr);
245}
246
247/*********************************************/
248/* HELPER: SearchModeID */
249/*********************************************/
250
251static int
252SiS_SearchModeID(struct SiS_Private *SiS_Pr, unsigned short *ModeNo,
253 unsigned short *ModeIdIndex)
254{
255 if ((*ModeNo) <= 0x13) {
256
257 if ((*ModeNo) != 0x03)
258 return 0;
259
260 (*ModeIdIndex) = 0;
261
262 } else {
263
264 for (*ModeIdIndex = 0;; (*ModeIdIndex)++) {
265
266 if (SiS_Pr->SiS_EModeIDTable[*ModeIdIndex].Ext_ModeID ==
267 (*ModeNo))
268 break;
269
270 if (SiS_Pr->SiS_EModeIDTable[*ModeIdIndex].Ext_ModeID ==
271 0xFF)
272 return 0;
273 }
274
275 }
276
277 return 1;
278}
279
280/*********************************************/
281/* HELPER: ENABLE CRT1 */
282/*********************************************/
283
284static void SiS_HandleCRT1(struct SiS_Private *SiS_Pr)
285{
286 /* Enable CRT1 gating */
287 SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3d4, SiS_Pr->SiS_MyCR63, 0xbf);
288}
289
290/*********************************************/
291/* HELPER: GetColorDepth */
292/*********************************************/
293
294static unsigned short
295SiS_GetColorDepth(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
296 unsigned short ModeIdIndex)
297{
298 static const unsigned short ColorDepth[6] = { 1, 2, 4, 4, 6, 8 };
299 unsigned short modeflag;
300 short index;
301
302 if (ModeNo <= 0x13) {
303 modeflag = SiS_Pr->SiS_SModeIDTable[ModeIdIndex].St_ModeFlag;
304 } else {
305 modeflag = SiS_Pr->SiS_EModeIDTable[ModeIdIndex].Ext_ModeFlag;
306 }
307
308 index = (modeflag & ModeTypeMask) - ModeEGA;
309 if (index < 0)
310 index = 0;
311 return ColorDepth[index];
312}
313
314/*********************************************/
315/* HELPER: GetOffset */
316/*********************************************/
317
318static unsigned short
319SiS_GetOffset(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
320 unsigned short ModeIdIndex, unsigned short rrti)
321{
322 unsigned short xres, temp, colordepth, infoflag;
323
324 infoflag = SiS_Pr->SiS_RefIndex[rrti].Ext_InfoFlag;
325 xres = SiS_Pr->SiS_RefIndex[rrti].XRes;
326
327 colordepth = SiS_GetColorDepth(SiS_Pr, ModeNo, ModeIdIndex);
328
329 temp = xres / 16;
330
331 if (infoflag & InterlaceMode)
332 temp <<= 1;
333
334 temp *= colordepth;
335
336 if (xres % 16)
337 temp += (colordepth >> 1);
338
339 return temp;
340}
341
342/*********************************************/
343/* SEQ */
344/*********************************************/
345
346static void
347SiS_SetSeqRegs(struct SiS_Private *SiS_Pr, unsigned short StandTableIndex)
348{
349 unsigned char SRdata;
350 int i;
351
352 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x00, 0x03);
353
354 SRdata = SiS_Pr->SiS_StandTable[StandTableIndex].SR[0] | 0x20;
355 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x01, SRdata);
356
357 for (i = 2; i <= 4; i++) {
358 SRdata = SiS_Pr->SiS_StandTable[StandTableIndex].SR[i - 1];
359 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, i, SRdata);
360 }
361}
362
363/*********************************************/
364/* MISC */
365/*********************************************/
366
367static void
368SiS_SetMiscRegs(struct SiS_Private *SiS_Pr, unsigned short StandTableIndex)
369{
370 unsigned char Miscdata = SiS_Pr->SiS_StandTable[StandTableIndex].MISC;
371
372 SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3c2, Miscdata);
373}
374
375/*********************************************/
376/* CRTC */
377/*********************************************/
378
379static void
380SiS_SetCRTCRegs(struct SiS_Private *SiS_Pr, unsigned short StandTableIndex)
381{
382 unsigned char CRTCdata;
383 unsigned short i;
384
385 SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3d4, 0x11, 0x7f);
386
387 for (i = 0; i <= 0x18; i++) {
388 CRTCdata = SiS_Pr->SiS_StandTable[StandTableIndex].CRTC[i];
389 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3d4, i, CRTCdata);
390 }
391}
392
393/*********************************************/
394/* ATT */
395/*********************************************/
396
397static void
398SiS_SetATTRegs(struct SiS_Private *SiS_Pr, unsigned short StandTableIndex)
399{
400 unsigned char ARdata;
401 unsigned short i;
402
403 for (i = 0; i <= 0x13; i++) {
404 ARdata = SiS_Pr->SiS_StandTable[StandTableIndex].ATTR[i];
405 SiS_GetRegByte(SiS_Pr, SiS_Pr->SiS_P3da);
406 SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3c0, i);
407 SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3c0, ARdata);
408 }
409 SiS_GetRegByte(SiS_Pr, SiS_Pr->SiS_P3da);
410 SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3c0, 0x14);
411 SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3c0, 0x00);
412
413 SiS_GetRegByte(SiS_Pr, SiS_Pr->SiS_P3da);
414 SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3c0, 0x20);
415 SiS_GetRegByte(SiS_Pr, SiS_Pr->SiS_P3da);
416}
417
418/*********************************************/
419/* GRC */
420/*********************************************/
421
422static void
423SiS_SetGRCRegs(struct SiS_Private *SiS_Pr, unsigned short StandTableIndex)
424{
425 unsigned char GRdata;
426 unsigned short i;
427
428 for (i = 0; i <= 0x08; i++) {
429 GRdata = SiS_Pr->SiS_StandTable[StandTableIndex].GRC[i];
430 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3ce, i, GRdata);
431 }
432
433 if (SiS_Pr->SiS_ModeType > ModeVGA) {
434 /* 256 color disable */
435 SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3ce, 0x05, 0xBF);
436 }
437}
438
439/*********************************************/
440/* CLEAR EXTENDED REGISTERS */
441/*********************************************/
442
443static void SiS_ClearExt1Regs(struct SiS_Private *SiS_Pr, unsigned short ModeNo)
444{
445 int i;
446
447 for (i = 0x0A; i <= 0x0E; i++) {
448 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, i, 0x00);
449 }
450
451 SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3c4, 0x37, 0xFE);
452}
453
454/*********************************************/
455/* Get rate index */
456/*********************************************/
457
458static unsigned short
459SiS_GetRatePtr(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
460 unsigned short ModeIdIndex)
461{
462 unsigned short rrti, i, index, temp;
463
464 if (ModeNo <= 0x13)
465 return 0xFFFF;
466
467 index = SiS_GetReg(SiS_Pr, SiS_Pr->SiS_P3d4, 0x33) & 0x0F;
468 if (index > 0)
469 index--;
470
471 rrti = SiS_Pr->SiS_EModeIDTable[ModeIdIndex].REFindex;
472 ModeNo = SiS_Pr->SiS_RefIndex[rrti].ModeID;
473
474 i = 0;
475 do {
476 if (SiS_Pr->SiS_RefIndex[rrti + i].ModeID != ModeNo)
477 break;
478
479 temp =
480 SiS_Pr->SiS_RefIndex[rrti + i].Ext_InfoFlag & ModeTypeMask;
481 if (temp < SiS_Pr->SiS_ModeType)
482 break;
483
484 i++;
485 index--;
486 } while (index != 0xFFFF);
487
488 i--;
489
490 return (rrti + i);
491}
492
493/*********************************************/
494/* SYNC */
495/*********************************************/
496
497static void SiS_SetCRT1Sync(struct SiS_Private *SiS_Pr, unsigned short rrti)
498{
499 unsigned short sync = SiS_Pr->SiS_RefIndex[rrti].Ext_InfoFlag >> 8;
500 sync &= 0xC0;
501 sync |= 0x2f;
502 SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3c2, sync);
503}
504
505/*********************************************/
506/* CRTC/2 */
507/*********************************************/
508
509static void
510SiS_SetCRT1CRTC(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
511 unsigned short ModeIdIndex, unsigned short rrti)
512{
513 unsigned char index;
514 unsigned short temp, i, j, modeflag;
515
516 SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3d4, 0x11, 0x7f);
517
518 modeflag = SiS_Pr->SiS_EModeIDTable[ModeIdIndex].Ext_ModeFlag;
519
520 index = SiS_Pr->SiS_RefIndex[rrti].Ext_CRT1CRTC;
521
522 for (i = 0, j = 0; i <= 7; i++, j++) {
523 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3d4, j,
524 SiS_Pr->SiS_CRT1Table[index].CR[i]);
525 }
526 for (j = 0x10; i <= 10; i++, j++) {
527 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3d4, j,
528 SiS_Pr->SiS_CRT1Table[index].CR[i]);
529 }
530 for (j = 0x15; i <= 12; i++, j++) {
531 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3d4, j,
532 SiS_Pr->SiS_CRT1Table[index].CR[i]);
533 }
534 for (j = 0x0A; i <= 15; i++, j++) {
535 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, j,
536 SiS_Pr->SiS_CRT1Table[index].CR[i]);
537 }
538
539 temp = SiS_Pr->SiS_CRT1Table[index].CR[16] & 0xE0;
540 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x0E, temp);
541
542 temp = ((SiS_Pr->SiS_CRT1Table[index].CR[16]) & 0x01) << 5;
543 if (modeflag & DoubleScanMode)
544 temp |= 0x80;
545 SiS_SetRegANDOR(SiS_Pr, SiS_Pr->SiS_P3d4, 0x09, 0x5F, temp);
546
547 if (SiS_Pr->SiS_ModeType > ModeVGA)
548 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3d4, 0x14, 0x4F);
549}
550
551/*********************************************/
552/* OFFSET & PITCH */
553/*********************************************/
554/* (partly overruled by SetPitch() in XF86) */
555/*********************************************/
556
557static void
558SiS_SetCRT1Offset(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
559 unsigned short ModeIdIndex, unsigned short rrti)
560{
561 unsigned short du = SiS_GetOffset(SiS_Pr, ModeNo, ModeIdIndex, rrti);
562 unsigned short infoflag = SiS_Pr->SiS_RefIndex[rrti].Ext_InfoFlag;
563 unsigned short temp;
564
565 temp = (du >> 8) & 0x0f;
566 SiS_SetRegANDOR(SiS_Pr, SiS_Pr->SiS_P3c4, 0x0E, 0xF0, temp);
567
568 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3d4, 0x13, (du & 0xFF));
569
570 if (infoflag & InterlaceMode)
571 du >>= 1;
572
573 du <<= 5;
574 temp = (du >> 8) & 0xff;
575 if (du & 0xff)
576 temp++;
577 temp++;
578 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x10, temp);
579}
580
581/*********************************************/
582/* VCLK */
583/*********************************************/
584
585static void
586SiS_SetCRT1VCLK(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
587 unsigned short rrti)
588{
589 unsigned short index = SiS_Pr->SiS_RefIndex[rrti].Ext_CRTVCLK;
590 unsigned short clka = SiS_Pr->SiS_VCLKData[index].SR2B;
591 unsigned short clkb = SiS_Pr->SiS_VCLKData[index].SR2C;
592
593 SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3c4, 0x31, 0xCF);
594
595 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x2B, clka);
596 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x2C, clkb);
597 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x2D, 0x01);
598}
599
600/*********************************************/
601/* FIFO */
602/*********************************************/
603
604static void
605SiS_SetCRT1FIFO_310(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
606 unsigned short mi)
607{
608 unsigned short modeflag = SiS_Pr->SiS_EModeIDTable[mi].Ext_ModeFlag;
609
610 /* disable auto-threshold */
611 SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3c4, 0x3D, 0xFE);
612
613 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x08, 0xAE);
614 SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3c4, 0x09, 0xF0);
615
616 if (ModeNo <= 0x13)
617 return;
618
619 if ((!(modeflag & DoubleScanMode)) || (!(modeflag & HalfDCLK))) {
620 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x08, 0x34);
621 SiS_SetRegOR(SiS_Pr, SiS_Pr->SiS_P3c4, 0x3D, 0x01);
622 }
623}
624
625/*********************************************/
626/* MODE REGISTERS */
627/*********************************************/
628
629static void
630SiS_SetVCLKState(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
631 unsigned short rrti)
632{
633 unsigned short data = 0, VCLK = 0, index = 0;
634
635 if (ModeNo > 0x13) {
636 index = SiS_Pr->SiS_RefIndex[rrti].Ext_CRTVCLK;
637 VCLK = SiS_Pr->SiS_VCLKData[index].CLOCK;
638 }
639
640 if (VCLK >= 166)
641 data |= 0x0c;
642 SiS_SetRegANDOR(SiS_Pr, SiS_Pr->SiS_P3c4, 0x32, 0xf3, data);
643
644 if (VCLK >= 166)
645 SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3c4, 0x1f, 0xe7);
646
647 /* DAC speed */
648 data = 0x03;
649 if (VCLK >= 260)
650 data = 0x00;
651 else if (VCLK >= 160)
652 data = 0x01;
653 else if (VCLK >= 135)
654 data = 0x02;
655
656 SiS_SetRegANDOR(SiS_Pr, SiS_Pr->SiS_P3c4, 0x07, 0xF8, data);
657}
658
659static void
660SiS_SetCRT1ModeRegs(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
661 unsigned short ModeIdIndex, unsigned short rrti)
662{
663 unsigned short data, infoflag = 0, modeflag;
664
665 if (ModeNo <= 0x13)
666 modeflag = SiS_Pr->SiS_SModeIDTable[ModeIdIndex].St_ModeFlag;
667 else {
668 modeflag = SiS_Pr->SiS_EModeIDTable[ModeIdIndex].Ext_ModeFlag;
669 infoflag = SiS_Pr->SiS_RefIndex[rrti].Ext_InfoFlag;
670 }
671
672 /* Disable DPMS */
673 SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3c4, 0x1F, 0x3F);
674
675 data = 0;
676 if (ModeNo > 0x13) {
677 if (SiS_Pr->SiS_ModeType > ModeEGA) {
678 data |= 0x02;
679 data |= ((SiS_Pr->SiS_ModeType - ModeVGA) << 2);
680 }
681 if (infoflag & InterlaceMode)
682 data |= 0x20;
683 }
684 SiS_SetRegANDOR(SiS_Pr, SiS_Pr->SiS_P3c4, 0x06, 0xC0, data);
685
686 data = 0;
687 if (infoflag & InterlaceMode) {
688 /* data = (Hsync / 8) - ((Htotal / 8) / 2) + 3 */
689 unsigned short hrs =
690 (SiS_GetReg(SiS_Pr, SiS_Pr->SiS_P3d4, 0x04) |
691 ((SiS_GetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x0b) & 0xc0) << 2))
692 - 3;
693 unsigned short hto =
694 (SiS_GetReg(SiS_Pr, SiS_Pr->SiS_P3d4, 0x00) |
695 ((SiS_GetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x0b) & 0x03) << 8))
696 + 5;
697 data = hrs - (hto >> 1) + 3;
698 }
699 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3d4, 0x19, (data & 0xFF));
700 SiS_SetRegANDOR(SiS_Pr, SiS_Pr->SiS_P3d4, 0x1a, 0xFC, (data >> 8));
701
702 if (modeflag & HalfDCLK)
703 SiS_SetRegOR(SiS_Pr, SiS_Pr->SiS_P3c4, 0x01, 0x08);
704
705 data = 0;
706 if (modeflag & LineCompareOff)
707 data = 0x08;
708 SiS_SetRegANDOR(SiS_Pr, SiS_Pr->SiS_P3c4, 0x0F, 0xB7, data);
709
710 if ((SiS_Pr->SiS_ModeType == ModeEGA) && (ModeNo > 0x13))
711 SiS_SetRegOR(SiS_Pr, SiS_Pr->SiS_P3c4, 0x0F, 0x40);
712
713 SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3c4, 0x31, 0xfb);
714
715 data = 0x60;
716 if (SiS_Pr->SiS_ModeType != ModeText) {
717 data ^= 0x60;
718 if (SiS_Pr->SiS_ModeType != ModeEGA)
719 data ^= 0xA0;
720 }
721 SiS_SetRegANDOR(SiS_Pr, SiS_Pr->SiS_P3c4, 0x21, 0x1F, data);
722
723 SiS_SetVCLKState(SiS_Pr, ModeNo, rrti);
724
725 if (SiS_GetReg(SiS_Pr, SiS_Pr->SiS_P3d4, 0x31) & 0x40)
726 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3d4, 0x52, 0x2c);
727 else
728 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3d4, 0x52, 0x6c);
729}
730
731/*********************************************/
732/* LOAD DAC */
733/*********************************************/
734
735static void
736SiS_WriteDAC(struct SiS_Private *SiS_Pr, unsigned long DACData,
737 unsigned short shiftflag, unsigned short dl, unsigned short ah,
738 unsigned short al, unsigned short dh)
739{
740 unsigned short d1, d2, d3;
741
742 switch (dl) {
743 case 0:
744 d1 = dh;
745 d2 = ah;
746 d3 = al;
747 break;
748 case 1:
749 d1 = ah;
750 d2 = al;
751 d3 = dh;
752 break;
753 default:
754 d1 = al;
755 d2 = dh;
756 d3 = ah;
757 }
758 SiS_SetRegByte(SiS_Pr, DACData, (d1 << shiftflag));
759 SiS_SetRegByte(SiS_Pr, DACData, (d2 << shiftflag));
760 SiS_SetRegByte(SiS_Pr, DACData, (d3 << shiftflag));
761}
762
763static void
764SiS_LoadDAC(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
765 unsigned short mi)
766{
767 unsigned short data, data2, time, i, j, k, m, n, o;
768 unsigned short si, di, bx, sf;
769 unsigned long DACAddr, DACData;
770 const unsigned char *table = NULL;
771
772 if (ModeNo < 0x13)
773 data = SiS_Pr->SiS_SModeIDTable[mi].St_ModeFlag;
774 else
775 data = SiS_Pr->SiS_EModeIDTable[mi].Ext_ModeFlag;
776
777 data &= DACInfoFlag;
778
779 j = time = 64;
780 if (data == 0x00)
781 table = SiS_MDA_DAC;
782 else if (data == 0x08)
783 table = SiS_CGA_DAC;
784 else if (data == 0x10)
785 table = SiS_EGA_DAC;
786 else {
787 j = 16;
788 time = 256;
789 table = SiS_VGA_DAC;
790 }
791
792 DACAddr = SiS_Pr->SiS_P3c8;
793 DACData = SiS_Pr->SiS_P3c9;
794 sf = 0;
795 SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3c6, 0xFF);
796
797 SiS_SetRegByte(SiS_Pr, DACAddr, 0x00);
798
799 for (i = 0; i < j; i++) {
800 data = table[i];
801 for (k = 0; k < 3; k++) {
802 data2 = 0;
803 if (data & 0x01)
804 data2 += 0x2A;
805 if (data & 0x02)
806 data2 += 0x15;
807 SiS_SetRegByte(SiS_Pr, DACData, (data2 << sf));
808 data >>= 2;
809 }
810 }
811
812 if (time == 256) {
813 for (i = 16; i < 32; i++) {
814 data = table[i] << sf;
815 for (k = 0; k < 3; k++)
816 SiS_SetRegByte(SiS_Pr, DACData, data);
817 }
818 si = 32;
819 for (m = 0; m < 9; m++) {
820 di = si;
821 bx = si + 4;
822 for (n = 0; n < 3; n++) {
823 for (o = 0; o < 5; o++) {
824 SiS_WriteDAC(SiS_Pr, DACData, sf, n,
825 table[di], table[bx],
826 table[si]);
827 si++;
828 }
829 si -= 2;
830 for (o = 0; o < 3; o++) {
831 SiS_WriteDAC(SiS_Pr, DACData, sf, n,
832 table[di], table[si],
833 table[bx]);
834 si--;
835 }
836 }
837 si += 5;
838 }
839 }
840}
841
842/*********************************************/
843/* SET CRT1 REGISTER GROUP */
844/*********************************************/
845
846static void
847SiS_SetCRT1Group(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
848 unsigned short ModeIdIndex)
849{
850 unsigned short StandTableIndex, rrti;
851
852 SiS_Pr->SiS_CRT1Mode = ModeNo;
853
854 if (ModeNo <= 0x13)
855 StandTableIndex = 0;
856 else
857 StandTableIndex = 1;
858
859 SiS_ResetSegmentRegisters(SiS_Pr);
860 SiS_SetSeqRegs(SiS_Pr, StandTableIndex);
861 SiS_SetMiscRegs(SiS_Pr, StandTableIndex);
862 SiS_SetCRTCRegs(SiS_Pr, StandTableIndex);
863 SiS_SetATTRegs(SiS_Pr, StandTableIndex);
864 SiS_SetGRCRegs(SiS_Pr, StandTableIndex);
865 SiS_ClearExt1Regs(SiS_Pr, ModeNo);
866
867 rrti = SiS_GetRatePtr(SiS_Pr, ModeNo, ModeIdIndex);
868
869 if (rrti != 0xFFFF) {
870 SiS_SetCRT1Sync(SiS_Pr, rrti);
871 SiS_SetCRT1CRTC(SiS_Pr, ModeNo, ModeIdIndex, rrti);
872 SiS_SetCRT1Offset(SiS_Pr, ModeNo, ModeIdIndex, rrti);
873 SiS_SetCRT1VCLK(SiS_Pr, ModeNo, rrti);
874 }
875
876 SiS_SetCRT1FIFO_310(SiS_Pr, ModeNo, ModeIdIndex);
877
878 SiS_SetCRT1ModeRegs(SiS_Pr, ModeNo, ModeIdIndex, rrti);
879
880 SiS_LoadDAC(SiS_Pr, ModeNo, ModeIdIndex);
881
882 SiS_DisplayOn(SiS_Pr);
883}
884
885/*********************************************/
886/* SiSSetMode() */
887/*********************************************/
888
889int SiSUSBSetMode(struct SiS_Private *SiS_Pr, unsigned short ModeNo)
890{
891 unsigned short ModeIdIndex;
892 unsigned long BaseAddr = SiS_Pr->IOAddress;
893
894 SiSUSB_InitPtr(SiS_Pr);
895 SiSUSBRegInit(SiS_Pr, BaseAddr);
896 SiS_GetSysFlags(SiS_Pr);
897
898 if (!(SiS_SearchModeID(SiS_Pr, &ModeNo, &ModeIdIndex)))
899 return 0;
900
901 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x05, 0x86);
902
903 SiSInitPCIetc(SiS_Pr);
904
905 ModeNo &= 0x7f;
906
907 SiS_Pr->SiS_ModeType =
908 SiS_Pr->SiS_EModeIDTable[ModeIdIndex].Ext_ModeFlag & ModeTypeMask;
909
910 SiS_Pr->SiS_SetFlag = LowModeTests;
911
912 /* Set mode on CRT1 */
913 SiS_SetCRT1Group(SiS_Pr, ModeNo, ModeIdIndex);
914
915 SiS_HandleCRT1(SiS_Pr);
916
917 SiS_DisplayOn(SiS_Pr);
918 SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3c6, 0xFF);
919
920 /* Store mode number */
921 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3d4, 0x34, ModeNo);
922
923 return 1;
924}
925
926int SiSUSBSetVESAMode(struct SiS_Private *SiS_Pr, unsigned short VModeNo)
927{
928 unsigned short ModeNo = 0;
929 int i;
930
931 SiSUSB_InitPtr(SiS_Pr);
932
933 if (VModeNo == 0x03) {
934
935 ModeNo = 0x03;
936
937 } else {
938
939 i = 0;
940 do {
941
942 if (SiS_Pr->SiS_EModeIDTable[i].Ext_VESAID == VModeNo) {
943 ModeNo = SiS_Pr->SiS_EModeIDTable[i].Ext_ModeID;
944 break;
945 }
946
947 } while (SiS_Pr->SiS_EModeIDTable[i++].Ext_ModeID != 0xff);
948
949 }
950
951 if (!ModeNo)
952 return 0;
953
954 return SiSUSBSetMode(SiS_Pr, ModeNo);
955}
1// SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause)
2/*
3 * sisusb - usb kernel driver for SiS315(E) based USB2VGA dongles
4 *
5 * Display mode initializing code
6 *
7 * Copyright (C) 2001-2005 by Thomas Winischhofer, Vienna, Austria
8 *
9 * If distributed as part of the Linux kernel, this code is licensed under the
10 * terms of the GPL v2.
11 *
12 * Otherwise, the following license terms apply:
13 *
14 * * Redistribution and use in source and binary forms, with or without
15 * * modification, are permitted provided that the following conditions
16 * * are met:
17 * * 1) Redistributions of source code must retain the above copyright
18 * * notice, this list of conditions and the following disclaimer.
19 * * 2) Redistributions in binary form must reproduce the above copyright
20 * * notice, this list of conditions and the following disclaimer in the
21 * * documentation and/or other materials provided with the distribution.
22 * * 3) The name of the author may not be used to endorse or promote products
23 * * derived from this software without specific prior written permission.
24 * *
25 * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
26 * * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
27 * * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
28 * * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
29 * * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
30 * * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
31 * * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
32 * * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
33 * * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
34 * * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
35 *
36 * Author: Thomas Winischhofer <thomas@winischhofer.net>
37 *
38 */
39
40#include <linux/module.h>
41#include <linux/kernel.h>
42#include <linux/errno.h>
43#include <linux/poll.h>
44#include <linux/spinlock.h>
45
46#include "sisusb.h"
47#include "sisusb_init.h"
48
49/*********************************************/
50/* POINTER INITIALIZATION */
51/*********************************************/
52
53static void SiSUSB_InitPtr(struct SiS_Private *SiS_Pr)
54{
55 SiS_Pr->SiS_ModeResInfo = SiSUSB_ModeResInfo;
56 SiS_Pr->SiS_StandTable = SiSUSB_StandTable;
57
58 SiS_Pr->SiS_SModeIDTable = SiSUSB_SModeIDTable;
59 SiS_Pr->SiS_EModeIDTable = SiSUSB_EModeIDTable;
60 SiS_Pr->SiS_RefIndex = SiSUSB_RefIndex;
61 SiS_Pr->SiS_CRT1Table = SiSUSB_CRT1Table;
62
63 SiS_Pr->SiS_VCLKData = SiSUSB_VCLKData;
64}
65
66/*********************************************/
67/* HELPER: SetReg, GetReg */
68/*********************************************/
69
70static void
71SiS_SetReg(struct SiS_Private *SiS_Pr, unsigned long port,
72 unsigned short index, unsigned short data)
73{
74 sisusb_setidxreg(SiS_Pr->sisusb, port, index, data);
75}
76
77static void
78SiS_SetRegByte(struct SiS_Private *SiS_Pr, unsigned long port,
79 unsigned short data)
80{
81 sisusb_setreg(SiS_Pr->sisusb, port, data);
82}
83
84static unsigned char
85SiS_GetReg(struct SiS_Private *SiS_Pr, unsigned long port, unsigned short index)
86{
87 u8 data;
88
89 sisusb_getidxreg(SiS_Pr->sisusb, port, index, &data);
90
91 return data;
92}
93
94static unsigned char
95SiS_GetRegByte(struct SiS_Private *SiS_Pr, unsigned long port)
96{
97 u8 data;
98
99 sisusb_getreg(SiS_Pr->sisusb, port, &data);
100
101 return data;
102}
103
104static void
105SiS_SetRegANDOR(struct SiS_Private *SiS_Pr, unsigned long port,
106 unsigned short index, unsigned short DataAND,
107 unsigned short DataOR)
108{
109 sisusb_setidxregandor(SiS_Pr->sisusb, port, index, DataAND, DataOR);
110}
111
112static void
113SiS_SetRegAND(struct SiS_Private *SiS_Pr, unsigned long port,
114 unsigned short index, unsigned short DataAND)
115{
116 sisusb_setidxregand(SiS_Pr->sisusb, port, index, DataAND);
117}
118
119static void
120SiS_SetRegOR(struct SiS_Private *SiS_Pr, unsigned long port,
121 unsigned short index, unsigned short DataOR)
122{
123 sisusb_setidxregor(SiS_Pr->sisusb, port, index, DataOR);
124}
125
126/*********************************************/
127/* HELPER: DisplayOn, DisplayOff */
128/*********************************************/
129
130static void SiS_DisplayOn(struct SiS_Private *SiS_Pr)
131{
132 SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3c4, 0x01, 0xDF);
133}
134
135/*********************************************/
136/* HELPER: Init Port Addresses */
137/*********************************************/
138
139static void SiSUSBRegInit(struct SiS_Private *SiS_Pr, unsigned long BaseAddr)
140{
141 SiS_Pr->SiS_P3c4 = BaseAddr + 0x14;
142 SiS_Pr->SiS_P3d4 = BaseAddr + 0x24;
143 SiS_Pr->SiS_P3c0 = BaseAddr + 0x10;
144 SiS_Pr->SiS_P3ce = BaseAddr + 0x1e;
145 SiS_Pr->SiS_P3c2 = BaseAddr + 0x12;
146 SiS_Pr->SiS_P3ca = BaseAddr + 0x1a;
147 SiS_Pr->SiS_P3c6 = BaseAddr + 0x16;
148 SiS_Pr->SiS_P3c7 = BaseAddr + 0x17;
149 SiS_Pr->SiS_P3c8 = BaseAddr + 0x18;
150 SiS_Pr->SiS_P3c9 = BaseAddr + 0x19;
151 SiS_Pr->SiS_P3cb = BaseAddr + 0x1b;
152 SiS_Pr->SiS_P3cc = BaseAddr + 0x1c;
153 SiS_Pr->SiS_P3cd = BaseAddr + 0x1d;
154 SiS_Pr->SiS_P3da = BaseAddr + 0x2a;
155 SiS_Pr->SiS_Part1Port = BaseAddr + SIS_CRT2_PORT_04;
156}
157
158/*********************************************/
159/* HELPER: GetSysFlags */
160/*********************************************/
161
162static void SiS_GetSysFlags(struct SiS_Private *SiS_Pr)
163{
164 SiS_Pr->SiS_MyCR63 = 0x63;
165}
166
167/*********************************************/
168/* HELPER: Init PCI & Engines */
169/*********************************************/
170
171static void SiSInitPCIetc(struct SiS_Private *SiS_Pr)
172{
173 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x20, 0xa1);
174 /* - Enable 2D (0x40)
175 * - Enable 3D (0x02)
176 * - Enable 3D vertex command fetch (0x10)
177 * - Enable 3D command parser (0x08)
178 * - Enable 3D G/L transformation engine (0x80)
179 */
180 SiS_SetRegOR(SiS_Pr, SiS_Pr->SiS_P3c4, 0x1E, 0xDA);
181}
182
183/*********************************************/
184/* HELPER: SET SEGMENT REGISTERS */
185/*********************************************/
186
187static void SiS_SetSegRegLower(struct SiS_Private *SiS_Pr, unsigned short value)
188{
189 unsigned short temp;
190
191 value &= 0x00ff;
192 temp = SiS_GetRegByte(SiS_Pr, SiS_Pr->SiS_P3cb) & 0xf0;
193 temp |= (value >> 4);
194 SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3cb, temp);
195 temp = SiS_GetRegByte(SiS_Pr, SiS_Pr->SiS_P3cd) & 0xf0;
196 temp |= (value & 0x0f);
197 SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3cd, temp);
198}
199
200static void SiS_SetSegRegUpper(struct SiS_Private *SiS_Pr, unsigned short value)
201{
202 unsigned short temp;
203
204 value &= 0x00ff;
205 temp = SiS_GetRegByte(SiS_Pr, SiS_Pr->SiS_P3cb) & 0x0f;
206 temp |= (value & 0xf0);
207 SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3cb, temp);
208 temp = SiS_GetRegByte(SiS_Pr, SiS_Pr->SiS_P3cd) & 0x0f;
209 temp |= (value << 4);
210 SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3cd, temp);
211}
212
213static void SiS_SetSegmentReg(struct SiS_Private *SiS_Pr, unsigned short value)
214{
215 SiS_SetSegRegLower(SiS_Pr, value);
216 SiS_SetSegRegUpper(SiS_Pr, value);
217}
218
219static void SiS_ResetSegmentReg(struct SiS_Private *SiS_Pr)
220{
221 SiS_SetSegmentReg(SiS_Pr, 0);
222}
223
224static void
225SiS_SetSegmentRegOver(struct SiS_Private *SiS_Pr, unsigned short value)
226{
227 unsigned short temp = value >> 8;
228
229 temp &= 0x07;
230 temp |= (temp << 4);
231 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x1d, temp);
232 SiS_SetSegmentReg(SiS_Pr, value);
233}
234
235static void SiS_ResetSegmentRegOver(struct SiS_Private *SiS_Pr)
236{
237 SiS_SetSegmentRegOver(SiS_Pr, 0);
238}
239
240static void SiS_ResetSegmentRegisters(struct SiS_Private *SiS_Pr)
241{
242 SiS_ResetSegmentReg(SiS_Pr);
243 SiS_ResetSegmentRegOver(SiS_Pr);
244}
245
246/*********************************************/
247/* HELPER: SearchModeID */
248/*********************************************/
249
250static int
251SiS_SearchModeID(struct SiS_Private *SiS_Pr, unsigned short *ModeNo,
252 unsigned short *ModeIdIndex)
253{
254 if ((*ModeNo) <= 0x13) {
255
256 if ((*ModeNo) != 0x03)
257 return 0;
258
259 (*ModeIdIndex) = 0;
260
261 } else {
262
263 for (*ModeIdIndex = 0;; (*ModeIdIndex)++) {
264
265 if (SiS_Pr->SiS_EModeIDTable[*ModeIdIndex].Ext_ModeID ==
266 (*ModeNo))
267 break;
268
269 if (SiS_Pr->SiS_EModeIDTable[*ModeIdIndex].Ext_ModeID ==
270 0xFF)
271 return 0;
272 }
273
274 }
275
276 return 1;
277}
278
279/*********************************************/
280/* HELPER: ENABLE CRT1 */
281/*********************************************/
282
283static void SiS_HandleCRT1(struct SiS_Private *SiS_Pr)
284{
285 /* Enable CRT1 gating */
286 SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3d4, SiS_Pr->SiS_MyCR63, 0xbf);
287}
288
289/*********************************************/
290/* HELPER: GetColorDepth */
291/*********************************************/
292
293static unsigned short
294SiS_GetColorDepth(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
295 unsigned short ModeIdIndex)
296{
297 static const unsigned short ColorDepth[6] = { 1, 2, 4, 4, 6, 8 };
298 unsigned short modeflag;
299 short index;
300
301 if (ModeNo <= 0x13) {
302 modeflag = SiS_Pr->SiS_SModeIDTable[ModeIdIndex].St_ModeFlag;
303 } else {
304 modeflag = SiS_Pr->SiS_EModeIDTable[ModeIdIndex].Ext_ModeFlag;
305 }
306
307 index = (modeflag & ModeTypeMask) - ModeEGA;
308 if (index < 0)
309 index = 0;
310 return ColorDepth[index];
311}
312
313/*********************************************/
314/* HELPER: GetOffset */
315/*********************************************/
316
317static unsigned short
318SiS_GetOffset(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
319 unsigned short ModeIdIndex, unsigned short rrti)
320{
321 unsigned short xres, temp, colordepth, infoflag;
322
323 infoflag = SiS_Pr->SiS_RefIndex[rrti].Ext_InfoFlag;
324 xres = SiS_Pr->SiS_RefIndex[rrti].XRes;
325
326 colordepth = SiS_GetColorDepth(SiS_Pr, ModeNo, ModeIdIndex);
327
328 temp = xres / 16;
329
330 if (infoflag & InterlaceMode)
331 temp <<= 1;
332
333 temp *= colordepth;
334
335 if (xres % 16)
336 temp += (colordepth >> 1);
337
338 return temp;
339}
340
341/*********************************************/
342/* SEQ */
343/*********************************************/
344
345static void
346SiS_SetSeqRegs(struct SiS_Private *SiS_Pr, unsigned short StandTableIndex)
347{
348 unsigned char SRdata;
349 int i;
350
351 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x00, 0x03);
352
353 SRdata = SiS_Pr->SiS_StandTable[StandTableIndex].SR[0] | 0x20;
354 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x01, SRdata);
355
356 for (i = 2; i <= 4; i++) {
357 SRdata = SiS_Pr->SiS_StandTable[StandTableIndex].SR[i - 1];
358 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, i, SRdata);
359 }
360}
361
362/*********************************************/
363/* MISC */
364/*********************************************/
365
366static void
367SiS_SetMiscRegs(struct SiS_Private *SiS_Pr, unsigned short StandTableIndex)
368{
369 unsigned char Miscdata = SiS_Pr->SiS_StandTable[StandTableIndex].MISC;
370
371 SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3c2, Miscdata);
372}
373
374/*********************************************/
375/* CRTC */
376/*********************************************/
377
378static void
379SiS_SetCRTCRegs(struct SiS_Private *SiS_Pr, unsigned short StandTableIndex)
380{
381 unsigned char CRTCdata;
382 unsigned short i;
383
384 SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3d4, 0x11, 0x7f);
385
386 for (i = 0; i <= 0x18; i++) {
387 CRTCdata = SiS_Pr->SiS_StandTable[StandTableIndex].CRTC[i];
388 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3d4, i, CRTCdata);
389 }
390}
391
392/*********************************************/
393/* ATT */
394/*********************************************/
395
396static void
397SiS_SetATTRegs(struct SiS_Private *SiS_Pr, unsigned short StandTableIndex)
398{
399 unsigned char ARdata;
400 unsigned short i;
401
402 for (i = 0; i <= 0x13; i++) {
403 ARdata = SiS_Pr->SiS_StandTable[StandTableIndex].ATTR[i];
404 SiS_GetRegByte(SiS_Pr, SiS_Pr->SiS_P3da);
405 SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3c0, i);
406 SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3c0, ARdata);
407 }
408 SiS_GetRegByte(SiS_Pr, SiS_Pr->SiS_P3da);
409 SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3c0, 0x14);
410 SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3c0, 0x00);
411
412 SiS_GetRegByte(SiS_Pr, SiS_Pr->SiS_P3da);
413 SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3c0, 0x20);
414 SiS_GetRegByte(SiS_Pr, SiS_Pr->SiS_P3da);
415}
416
417/*********************************************/
418/* GRC */
419/*********************************************/
420
421static void
422SiS_SetGRCRegs(struct SiS_Private *SiS_Pr, unsigned short StandTableIndex)
423{
424 unsigned char GRdata;
425 unsigned short i;
426
427 for (i = 0; i <= 0x08; i++) {
428 GRdata = SiS_Pr->SiS_StandTable[StandTableIndex].GRC[i];
429 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3ce, i, GRdata);
430 }
431
432 if (SiS_Pr->SiS_ModeType > ModeVGA) {
433 /* 256 color disable */
434 SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3ce, 0x05, 0xBF);
435 }
436}
437
438/*********************************************/
439/* CLEAR EXTENDED REGISTERS */
440/*********************************************/
441
442static void SiS_ClearExt1Regs(struct SiS_Private *SiS_Pr, unsigned short ModeNo)
443{
444 int i;
445
446 for (i = 0x0A; i <= 0x0E; i++) {
447 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, i, 0x00);
448 }
449
450 SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3c4, 0x37, 0xFE);
451}
452
453/*********************************************/
454/* Get rate index */
455/*********************************************/
456
457static unsigned short
458SiS_GetRatePtr(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
459 unsigned short ModeIdIndex)
460{
461 unsigned short rrti, i, index, temp;
462
463 if (ModeNo <= 0x13)
464 return 0xFFFF;
465
466 index = SiS_GetReg(SiS_Pr, SiS_Pr->SiS_P3d4, 0x33) & 0x0F;
467 if (index > 0)
468 index--;
469
470 rrti = SiS_Pr->SiS_EModeIDTable[ModeIdIndex].REFindex;
471 ModeNo = SiS_Pr->SiS_RefIndex[rrti].ModeID;
472
473 i = 0;
474 do {
475 if (SiS_Pr->SiS_RefIndex[rrti + i].ModeID != ModeNo)
476 break;
477
478 temp =
479 SiS_Pr->SiS_RefIndex[rrti + i].Ext_InfoFlag & ModeTypeMask;
480 if (temp < SiS_Pr->SiS_ModeType)
481 break;
482
483 i++;
484 index--;
485 } while (index != 0xFFFF);
486
487 i--;
488
489 return (rrti + i);
490}
491
492/*********************************************/
493/* SYNC */
494/*********************************************/
495
496static void SiS_SetCRT1Sync(struct SiS_Private *SiS_Pr, unsigned short rrti)
497{
498 unsigned short sync = SiS_Pr->SiS_RefIndex[rrti].Ext_InfoFlag >> 8;
499 sync &= 0xC0;
500 sync |= 0x2f;
501 SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3c2, sync);
502}
503
504/*********************************************/
505/* CRTC/2 */
506/*********************************************/
507
508static void
509SiS_SetCRT1CRTC(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
510 unsigned short ModeIdIndex, unsigned short rrti)
511{
512 unsigned char index;
513 unsigned short temp, i, j, modeflag;
514
515 SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3d4, 0x11, 0x7f);
516
517 modeflag = SiS_Pr->SiS_EModeIDTable[ModeIdIndex].Ext_ModeFlag;
518
519 index = SiS_Pr->SiS_RefIndex[rrti].Ext_CRT1CRTC;
520
521 for (i = 0, j = 0; i <= 7; i++, j++) {
522 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3d4, j,
523 SiS_Pr->SiS_CRT1Table[index].CR[i]);
524 }
525 for (j = 0x10; i <= 10; i++, j++) {
526 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3d4, j,
527 SiS_Pr->SiS_CRT1Table[index].CR[i]);
528 }
529 for (j = 0x15; i <= 12; i++, j++) {
530 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3d4, j,
531 SiS_Pr->SiS_CRT1Table[index].CR[i]);
532 }
533 for (j = 0x0A; i <= 15; i++, j++) {
534 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, j,
535 SiS_Pr->SiS_CRT1Table[index].CR[i]);
536 }
537
538 temp = SiS_Pr->SiS_CRT1Table[index].CR[16] & 0xE0;
539 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x0E, temp);
540
541 temp = ((SiS_Pr->SiS_CRT1Table[index].CR[16]) & 0x01) << 5;
542 if (modeflag & DoubleScanMode)
543 temp |= 0x80;
544 SiS_SetRegANDOR(SiS_Pr, SiS_Pr->SiS_P3d4, 0x09, 0x5F, temp);
545
546 if (SiS_Pr->SiS_ModeType > ModeVGA)
547 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3d4, 0x14, 0x4F);
548}
549
550/*********************************************/
551/* OFFSET & PITCH */
552/*********************************************/
553/* (partly overruled by SetPitch() in XF86) */
554/*********************************************/
555
556static void
557SiS_SetCRT1Offset(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
558 unsigned short ModeIdIndex, unsigned short rrti)
559{
560 unsigned short du = SiS_GetOffset(SiS_Pr, ModeNo, ModeIdIndex, rrti);
561 unsigned short infoflag = SiS_Pr->SiS_RefIndex[rrti].Ext_InfoFlag;
562 unsigned short temp;
563
564 temp = (du >> 8) & 0x0f;
565 SiS_SetRegANDOR(SiS_Pr, SiS_Pr->SiS_P3c4, 0x0E, 0xF0, temp);
566
567 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3d4, 0x13, (du & 0xFF));
568
569 if (infoflag & InterlaceMode)
570 du >>= 1;
571
572 du <<= 5;
573 temp = (du >> 8) & 0xff;
574 if (du & 0xff)
575 temp++;
576 temp++;
577 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x10, temp);
578}
579
580/*********************************************/
581/* VCLK */
582/*********************************************/
583
584static void
585SiS_SetCRT1VCLK(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
586 unsigned short rrti)
587{
588 unsigned short index = SiS_Pr->SiS_RefIndex[rrti].Ext_CRTVCLK;
589 unsigned short clka = SiS_Pr->SiS_VCLKData[index].SR2B;
590 unsigned short clkb = SiS_Pr->SiS_VCLKData[index].SR2C;
591
592 SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3c4, 0x31, 0xCF);
593
594 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x2B, clka);
595 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x2C, clkb);
596 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x2D, 0x01);
597}
598
599/*********************************************/
600/* FIFO */
601/*********************************************/
602
603static void
604SiS_SetCRT1FIFO_310(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
605 unsigned short mi)
606{
607 unsigned short modeflag = SiS_Pr->SiS_EModeIDTable[mi].Ext_ModeFlag;
608
609 /* disable auto-threshold */
610 SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3c4, 0x3D, 0xFE);
611
612 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x08, 0xAE);
613 SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3c4, 0x09, 0xF0);
614
615 if (ModeNo <= 0x13)
616 return;
617
618 if ((!(modeflag & DoubleScanMode)) || (!(modeflag & HalfDCLK))) {
619 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x08, 0x34);
620 SiS_SetRegOR(SiS_Pr, SiS_Pr->SiS_P3c4, 0x3D, 0x01);
621 }
622}
623
624/*********************************************/
625/* MODE REGISTERS */
626/*********************************************/
627
628static void
629SiS_SetVCLKState(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
630 unsigned short rrti)
631{
632 unsigned short data = 0, VCLK = 0, index = 0;
633
634 if (ModeNo > 0x13) {
635 index = SiS_Pr->SiS_RefIndex[rrti].Ext_CRTVCLK;
636 VCLK = SiS_Pr->SiS_VCLKData[index].CLOCK;
637 }
638
639 if (VCLK >= 166)
640 data |= 0x0c;
641 SiS_SetRegANDOR(SiS_Pr, SiS_Pr->SiS_P3c4, 0x32, 0xf3, data);
642
643 if (VCLK >= 166)
644 SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3c4, 0x1f, 0xe7);
645
646 /* DAC speed */
647 data = 0x03;
648 if (VCLK >= 260)
649 data = 0x00;
650 else if (VCLK >= 160)
651 data = 0x01;
652 else if (VCLK >= 135)
653 data = 0x02;
654
655 SiS_SetRegANDOR(SiS_Pr, SiS_Pr->SiS_P3c4, 0x07, 0xF8, data);
656}
657
658static void
659SiS_SetCRT1ModeRegs(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
660 unsigned short ModeIdIndex, unsigned short rrti)
661{
662 unsigned short data, infoflag = 0, modeflag;
663
664 if (ModeNo <= 0x13)
665 modeflag = SiS_Pr->SiS_SModeIDTable[ModeIdIndex].St_ModeFlag;
666 else {
667 modeflag = SiS_Pr->SiS_EModeIDTable[ModeIdIndex].Ext_ModeFlag;
668 infoflag = SiS_Pr->SiS_RefIndex[rrti].Ext_InfoFlag;
669 }
670
671 /* Disable DPMS */
672 SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3c4, 0x1F, 0x3F);
673
674 data = 0;
675 if (ModeNo > 0x13) {
676 if (SiS_Pr->SiS_ModeType > ModeEGA) {
677 data |= 0x02;
678 data |= ((SiS_Pr->SiS_ModeType - ModeVGA) << 2);
679 }
680 if (infoflag & InterlaceMode)
681 data |= 0x20;
682 }
683 SiS_SetRegANDOR(SiS_Pr, SiS_Pr->SiS_P3c4, 0x06, 0xC0, data);
684
685 data = 0;
686 if (infoflag & InterlaceMode) {
687 /* data = (Hsync / 8) - ((Htotal / 8) / 2) + 3 */
688 unsigned short hrs =
689 (SiS_GetReg(SiS_Pr, SiS_Pr->SiS_P3d4, 0x04) |
690 ((SiS_GetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x0b) & 0xc0) << 2))
691 - 3;
692 unsigned short hto =
693 (SiS_GetReg(SiS_Pr, SiS_Pr->SiS_P3d4, 0x00) |
694 ((SiS_GetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x0b) & 0x03) << 8))
695 + 5;
696 data = hrs - (hto >> 1) + 3;
697 }
698 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3d4, 0x19, (data & 0xFF));
699 SiS_SetRegANDOR(SiS_Pr, SiS_Pr->SiS_P3d4, 0x1a, 0xFC, (data >> 8));
700
701 if (modeflag & HalfDCLK)
702 SiS_SetRegOR(SiS_Pr, SiS_Pr->SiS_P3c4, 0x01, 0x08);
703
704 data = 0;
705 if (modeflag & LineCompareOff)
706 data = 0x08;
707 SiS_SetRegANDOR(SiS_Pr, SiS_Pr->SiS_P3c4, 0x0F, 0xB7, data);
708
709 if ((SiS_Pr->SiS_ModeType == ModeEGA) && (ModeNo > 0x13))
710 SiS_SetRegOR(SiS_Pr, SiS_Pr->SiS_P3c4, 0x0F, 0x40);
711
712 SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3c4, 0x31, 0xfb);
713
714 data = 0x60;
715 if (SiS_Pr->SiS_ModeType != ModeText) {
716 data ^= 0x60;
717 if (SiS_Pr->SiS_ModeType != ModeEGA)
718 data ^= 0xA0;
719 }
720 SiS_SetRegANDOR(SiS_Pr, SiS_Pr->SiS_P3c4, 0x21, 0x1F, data);
721
722 SiS_SetVCLKState(SiS_Pr, ModeNo, rrti);
723
724 if (SiS_GetReg(SiS_Pr, SiS_Pr->SiS_P3d4, 0x31) & 0x40)
725 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3d4, 0x52, 0x2c);
726 else
727 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3d4, 0x52, 0x6c);
728}
729
730/*********************************************/
731/* LOAD DAC */
732/*********************************************/
733
734static void
735SiS_WriteDAC(struct SiS_Private *SiS_Pr, unsigned long DACData,
736 unsigned short shiftflag, unsigned short dl, unsigned short ah,
737 unsigned short al, unsigned short dh)
738{
739 unsigned short d1, d2, d3;
740
741 switch (dl) {
742 case 0:
743 d1 = dh;
744 d2 = ah;
745 d3 = al;
746 break;
747 case 1:
748 d1 = ah;
749 d2 = al;
750 d3 = dh;
751 break;
752 default:
753 d1 = al;
754 d2 = dh;
755 d3 = ah;
756 }
757 SiS_SetRegByte(SiS_Pr, DACData, (d1 << shiftflag));
758 SiS_SetRegByte(SiS_Pr, DACData, (d2 << shiftflag));
759 SiS_SetRegByte(SiS_Pr, DACData, (d3 << shiftflag));
760}
761
762static void
763SiS_LoadDAC(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
764 unsigned short mi)
765{
766 unsigned short data, data2, time, i, j, k, m, n, o;
767 unsigned short si, di, bx, sf;
768 unsigned long DACAddr, DACData;
769 const unsigned char *table = NULL;
770
771 if (ModeNo < 0x13)
772 data = SiS_Pr->SiS_SModeIDTable[mi].St_ModeFlag;
773 else
774 data = SiS_Pr->SiS_EModeIDTable[mi].Ext_ModeFlag;
775
776 data &= DACInfoFlag;
777
778 j = time = 64;
779 if (data == 0x00)
780 table = SiS_MDA_DAC;
781 else if (data == 0x08)
782 table = SiS_CGA_DAC;
783 else if (data == 0x10)
784 table = SiS_EGA_DAC;
785 else {
786 j = 16;
787 time = 256;
788 table = SiS_VGA_DAC;
789 }
790
791 DACAddr = SiS_Pr->SiS_P3c8;
792 DACData = SiS_Pr->SiS_P3c9;
793 sf = 0;
794 SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3c6, 0xFF);
795
796 SiS_SetRegByte(SiS_Pr, DACAddr, 0x00);
797
798 for (i = 0; i < j; i++) {
799 data = table[i];
800 for (k = 0; k < 3; k++) {
801 data2 = 0;
802 if (data & 0x01)
803 data2 += 0x2A;
804 if (data & 0x02)
805 data2 += 0x15;
806 SiS_SetRegByte(SiS_Pr, DACData, (data2 << sf));
807 data >>= 2;
808 }
809 }
810
811 if (time == 256) {
812 for (i = 16; i < 32; i++) {
813 data = table[i] << sf;
814 for (k = 0; k < 3; k++)
815 SiS_SetRegByte(SiS_Pr, DACData, data);
816 }
817 si = 32;
818 for (m = 0; m < 9; m++) {
819 di = si;
820 bx = si + 4;
821 for (n = 0; n < 3; n++) {
822 for (o = 0; o < 5; o++) {
823 SiS_WriteDAC(SiS_Pr, DACData, sf, n,
824 table[di], table[bx],
825 table[si]);
826 si++;
827 }
828 si -= 2;
829 for (o = 0; o < 3; o++) {
830 SiS_WriteDAC(SiS_Pr, DACData, sf, n,
831 table[di], table[si],
832 table[bx]);
833 si--;
834 }
835 }
836 si += 5;
837 }
838 }
839}
840
841/*********************************************/
842/* SET CRT1 REGISTER GROUP */
843/*********************************************/
844
845static void
846SiS_SetCRT1Group(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
847 unsigned short ModeIdIndex)
848{
849 unsigned short StandTableIndex, rrti;
850
851 SiS_Pr->SiS_CRT1Mode = ModeNo;
852
853 if (ModeNo <= 0x13)
854 StandTableIndex = 0;
855 else
856 StandTableIndex = 1;
857
858 SiS_ResetSegmentRegisters(SiS_Pr);
859 SiS_SetSeqRegs(SiS_Pr, StandTableIndex);
860 SiS_SetMiscRegs(SiS_Pr, StandTableIndex);
861 SiS_SetCRTCRegs(SiS_Pr, StandTableIndex);
862 SiS_SetATTRegs(SiS_Pr, StandTableIndex);
863 SiS_SetGRCRegs(SiS_Pr, StandTableIndex);
864 SiS_ClearExt1Regs(SiS_Pr, ModeNo);
865
866 rrti = SiS_GetRatePtr(SiS_Pr, ModeNo, ModeIdIndex);
867
868 if (rrti != 0xFFFF) {
869 SiS_SetCRT1Sync(SiS_Pr, rrti);
870 SiS_SetCRT1CRTC(SiS_Pr, ModeNo, ModeIdIndex, rrti);
871 SiS_SetCRT1Offset(SiS_Pr, ModeNo, ModeIdIndex, rrti);
872 SiS_SetCRT1VCLK(SiS_Pr, ModeNo, rrti);
873 }
874
875 SiS_SetCRT1FIFO_310(SiS_Pr, ModeNo, ModeIdIndex);
876
877 SiS_SetCRT1ModeRegs(SiS_Pr, ModeNo, ModeIdIndex, rrti);
878
879 SiS_LoadDAC(SiS_Pr, ModeNo, ModeIdIndex);
880
881 SiS_DisplayOn(SiS_Pr);
882}
883
884/*********************************************/
885/* SiSSetMode() */
886/*********************************************/
887
888int SiSUSBSetMode(struct SiS_Private *SiS_Pr, unsigned short ModeNo)
889{
890 unsigned short ModeIdIndex;
891 unsigned long BaseAddr = SiS_Pr->IOAddress;
892
893 SiSUSB_InitPtr(SiS_Pr);
894 SiSUSBRegInit(SiS_Pr, BaseAddr);
895 SiS_GetSysFlags(SiS_Pr);
896
897 if (!(SiS_SearchModeID(SiS_Pr, &ModeNo, &ModeIdIndex)))
898 return 0;
899
900 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x05, 0x86);
901
902 SiSInitPCIetc(SiS_Pr);
903
904 ModeNo &= 0x7f;
905
906 SiS_Pr->SiS_ModeType =
907 SiS_Pr->SiS_EModeIDTable[ModeIdIndex].Ext_ModeFlag & ModeTypeMask;
908
909 SiS_Pr->SiS_SetFlag = LowModeTests;
910
911 /* Set mode on CRT1 */
912 SiS_SetCRT1Group(SiS_Pr, ModeNo, ModeIdIndex);
913
914 SiS_HandleCRT1(SiS_Pr);
915
916 SiS_DisplayOn(SiS_Pr);
917 SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3c6, 0xFF);
918
919 /* Store mode number */
920 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3d4, 0x34, ModeNo);
921
922 return 1;
923}
924
925int SiSUSBSetVESAMode(struct SiS_Private *SiS_Pr, unsigned short VModeNo)
926{
927 unsigned short ModeNo = 0;
928 int i;
929
930 SiSUSB_InitPtr(SiS_Pr);
931
932 if (VModeNo == 0x03) {
933
934 ModeNo = 0x03;
935
936 } else {
937
938 i = 0;
939 do {
940
941 if (SiS_Pr->SiS_EModeIDTable[i].Ext_VESAID == VModeNo) {
942 ModeNo = SiS_Pr->SiS_EModeIDTable[i].Ext_ModeID;
943 break;
944 }
945
946 } while (SiS_Pr->SiS_EModeIDTable[i++].Ext_ModeID != 0xff);
947
948 }
949
950 if (!ModeNo)
951 return 0;
952
953 return SiSUSBSetMode(SiS_Pr, ModeNo);
954}