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