git.oblomov.eu Git - linux-2.6/blob - drivers/usb/misc/sisusbvga/sisusb_init.c

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