drivers/staging/xgifb/XGI_main_26.c

   1 /*
   2  * XG20, XG21, XG40, XG42 frame buffer device
   3  * for Linux kernels  2.5.x, 2.6.x
   4  * Base on TW's sis fbdev code.
   5  */
   6
   7 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
   8
   9 /* #include <linux/config.h> */
  10 #include <linux/module.h>
  11 #include <linux/moduleparam.h>
  12 #include <linux/kernel.h>
  13 #include <linux/spinlock.h>
  14 #include <linux/errno.h>
  15 #include <linux/string.h>
  16 #include <linux/mm.h>
  17 #include <linux/tty.h>
  18 #include <linux/slab.h>
  19 #include <linux/delay.h>
  20 #include <linux/fb.h>
  21 #include <linux/console.h>
  22 #include <linux/selection.h>
  23 #include <linux/ioport.h>
  24 #include <linux/init.h>
  25 #include <linux/pci.h>
  26 #include <linux/vt_kern.h>
  27 #include <linux/capability.h>
  28 #include <linux/fs.h>
  29 #include <linux/types.h>
  30 #include <linux/proc_fs.h>
  31
  32 #include <linux/io.h>
  33 #ifdef CONFIG_MTRR
  34 #include <asm/mtrr.h>
  35 #endif
  36
  37 #include "XGIfb.h"
  38 #include "vgatypes.h"
  39 #include "XGI_main.h"
  40 #include "vb_init.h"
  41 #include "vb_util.h"
  42 #include "vb_setmode.h"
  43
  44 #define Index_CR_GPIO_Reg1 0x48
  45 #define Index_CR_GPIO_Reg3 0x4a
  46
  47 #define GPIOG_EN    (1<<6)
  48 #define GPIOG_READ  (1<<1)
  49
  50 static char *forcecrt2type;
  51 static char *mode;
  52 static int vesa = -1;
  53 static unsigned int refresh_rate;
  54
  55 /* -------------------- Macro definitions ---------------------------- */
  56
  57 #undef XGIFBDEBUG
  58
  59 #ifdef XGIFBDEBUG
  60 #define DPRINTK(fmt, args...) pr_debug("%s: " fmt, __func__ , ## args)
  61 #else
  62 #define DPRINTK(fmt, args...)
  63 #endif
  64
  65 #ifdef XGIFBDEBUG
  66 static void dumpVGAReg(void)
  67 {
  68         u8 i, reg;
  69
  70         xgifb_reg_set(XGISR, 0x05, 0x86);
  71         /*
  72         xgifb_reg_set(XGISR, 0x08, 0x4f);
  73         xgifb_reg_set(XGISR, 0x0f, 0x20);
  74         xgifb_reg_set(XGISR, 0x11, 0x4f);
  75         xgifb_reg_set(XGISR, 0x13, 0x45);
  76         xgifb_reg_set(XGISR, 0x14, 0x51);
  77         xgifb_reg_set(XGISR, 0x1e, 0x41);
  78         xgifb_reg_set(XGISR, 0x1f, 0x0);
  79         xgifb_reg_set(XGISR, 0x20, 0xa1);
  80         xgifb_reg_set(XGISR, 0x22, 0xfb);
  81         xgifb_reg_set(XGISR, 0x26, 0x22);
  82         xgifb_reg_set(XGISR, 0x3e, 0x07);
  83         */
  84
  85         /* xgifb_reg_set(XGICR, 0x19, 0x00); */
  86         /* xgifb_reg_set(XGICR, 0x1a, 0x3C); */
  87         /* xgifb_reg_set(XGICR, 0x22, 0xff); */
  88         /* xgifb_reg_set(XGICR, 0x3D, 0x10); */
  89
  90         /* xgifb_reg_set(XGICR, 0x4a, 0xf3); */
  91
  92         /* xgifb_reg_set(XGICR, 0x57, 0x0); */
  93         /* xgifb_reg_set(XGICR, 0x7a, 0x2c); */
  94
  95         /* xgifb_reg_set(XGICR, 0x82, 0xcc); */
  96         /* xgifb_reg_set(XGICR, 0x8c, 0x0); */
  97         /*
  98         xgifb_reg_set(XGICR, 0x99, 0x1);
  99         xgifb_reg_set(XGICR, 0x41, 0x40);
 100         */
 101
 102         for (i = 0; i < 0x4f; i++) {
 103                 reg = xgifb_reg_get(XGISR, i);
 104                 printk("\no 3c4 %x", i);
 105                 printk("\ni 3c5 => %x", reg);
 106         }
 107
 108         for (i = 0; i < 0xF0; i++) {
 109                 reg = xgifb_reg_get(XGICR, i);
 110                 printk("\no 3d4 %x", i);
 111                 printk("\ni 3d5 => %x", reg);
 112         }
 113         /*
 114         xgifb_reg_set(XGIPART1,0x2F,1);
 115         for (i=1; i < 0x50; i++) {
 116                 reg = xgifb_reg_get(XGIPART1, i);
 117                 printk("\no d004 %x", i);
 118                 printk("\ni d005 => %x", reg);
 119         }
 120
 121         for (i=0; i < 0x50; i++) {
 122                  reg = xgifb_reg_get(XGIPART2, i);
 123                  printk("\no d010 %x", i);
 124                  printk("\ni d011 => %x", reg);
 125         }
 126         for (i=0; i < 0x50; i++) {
 127                 reg = xgifb_reg_get(XGIPART3, i);
 128                 printk("\no d012 %x",i);
 129                 printk("\ni d013 => %x",reg);
 130         }
 131         for (i=0; i < 0x50; i++) {
 132                 reg = xgifb_reg_get(XGIPART4, i);
 133                 printk("\no d014 %x",i);
 134                 printk("\ni d015 => %x",reg);
 135         }
 136         */
 137 }
 138 #else
 139 static inline void dumpVGAReg(void)
 140 {
 141 }
 142 #endif
 143
 144 #if 1
 145 #define DEBUGPRN(x)
 146 #else
 147 #define DEBUGPRN(x) pr_info(x "\n");
 148 #endif
 149
 150 /* --------------- Hardware Access Routines -------------------------- */
 151
 152 static int XGIfb_mode_rate_to_dclock(struct vb_device_info *XGI_Pr,
 153                 struct xgi_hw_device_info *HwDeviceExtension,
 154                 unsigned char modeno, unsigned char rateindex)
 155 {
 156         unsigned short ModeNo = modeno;
 157         unsigned short ModeIdIndex = 0, ClockIndex = 0;
 158         unsigned short RefreshRateTableIndex = 0;
 159
 160         /* unsigned long  temp = 0; */
 161         int Clock;
 162         InitTo330Pointer(HwDeviceExtension->jChipType, XGI_Pr);
 163
 164         RefreshRateTableIndex = XGI_GetRatePtrCRT2(HwDeviceExtension, ModeNo,
 165                         ModeIdIndex, XGI_Pr);
 166
 167         /*
 168         temp = XGI_SearchModeID(ModeNo , &ModeIdIndex,  XGI_Pr) ;
 169         if (!temp) {
 170                 printk(KERN_ERR "Could not find mode %x\n", ModeNo);
 171                 return 65000;
 172         }
 173
 174         RefreshRateTableIndex = XGI_Pr->EModeIDTable[ModeIdIndex].REFindex;
 175         RefreshRateTableIndex += (rateindex - 1);
 176
 177         */
 178         ClockIndex = XGI_Pr->RefIndex[RefreshRateTableIndex].Ext_CRTVCLK;
 179
 180         Clock = XGI_Pr->VCLKData[ClockIndex].CLOCK * 1000;
 181
 182         return Clock;
 183 }
 184
 185 static int XGIfb_mode_rate_to_ddata(struct vb_device_info *XGI_Pr,
 186                 struct xgi_hw_device_info *HwDeviceExtension,
 187                 unsigned char modeno, unsigned char rateindex,
 188                 u32 *left_margin, u32 *right_margin, u32 *upper_margin,
 189                 u32 *lower_margin, u32 *hsync_len, u32 *vsync_len, u32 *sync,
 190                 u32 *vmode)
 191 {
 192         unsigned short ModeNo = modeno;
 193         unsigned short ModeIdIndex, index = 0;
 194         unsigned short RefreshRateTableIndex = 0;
 195
 196         unsigned short VRE, VBE, VRS, VBS, VDE, VT;
 197         unsigned short HRE, HBE, HRS, HBS, HDE, HT;
 198         unsigned char sr_data, cr_data, cr_data2;
 199         unsigned long cr_data3;
 200         int A, B, C, D, E, F, temp, j;
 201         InitTo330Pointer(HwDeviceExtension->jChipType, XGI_Pr);
 202         if (!XGI_SearchModeID(ModeNo, &ModeIdIndex, XGI_Pr))
 203                 return 0;
 204         RefreshRateTableIndex = XGI_GetRatePtrCRT2(HwDeviceExtension, ModeNo,
 205                         ModeIdIndex, XGI_Pr);
 206         index = XGI_Pr->RefIndex[RefreshRateTableIndex].Ext_CRT1CRTC;
 207
 208         sr_data = XGI_Pr->XGINEWUB_CRT1Table[index].CR[5];
 209
 210         cr_data = XGI_Pr->XGINEWUB_CRT1Table[index].CR[0];
 211
 212         /* Horizontal total */
 213         HT = (cr_data & 0xff) | ((unsigned short) (sr_data & 0x03) << 8);
 214         A = HT + 5;
 215
 216         HDE = (XGI_Pr->RefIndex[RefreshRateTableIndex].XRes >> 3) - 1;
 217         E = HDE + 1;
 218
 219         cr_data = XGI_Pr->XGINEWUB_CRT1Table[index].CR[3];
 220
 221         /* Horizontal retrace (=sync) start */
 222         HRS = (cr_data & 0xff) | ((unsigned short) (sr_data & 0xC0) << 2);
 223         F = HRS - E - 3;
 224
 225         cr_data = XGI_Pr->XGINEWUB_CRT1Table[index].CR[1];
 226
 227         /* Horizontal blank start */
 228         HBS = (cr_data & 0xff) | ((unsigned short) (sr_data & 0x30) << 4);
 229
 230         sr_data = XGI_Pr->XGINEWUB_CRT1Table[index].CR[6];
 231
 232         cr_data = XGI_Pr->XGINEWUB_CRT1Table[index].CR[2];
 233
 234         cr_data2 = XGI_Pr->XGINEWUB_CRT1Table[index].CR[4];
 235
 236         /* Horizontal blank end */
 237         HBE = (cr_data & 0x1f) | ((unsigned short) (cr_data2 & 0x80) >> 2)
 238                         | ((unsigned short) (sr_data & 0x03) << 6);
 239
 240         /* Horizontal retrace (=sync) end */
 241         HRE = (cr_data2 & 0x1f) | ((sr_data & 0x04) << 3);
 242
 243         temp = HBE - ((E - 1) & 255);
 244         B = (temp > 0) ? temp : (temp + 256);
 245
 246         temp = HRE - ((E + F + 3) & 63);
 247         C = (temp > 0) ? temp : (temp + 64);
 248
 249         D = B - F - C;
 250
 251         *left_margin = D * 8;
 252         *right_margin = F * 8;
 253         *hsync_len = C * 8;
 254
 255         sr_data = XGI_Pr->XGINEWUB_CRT1Table[index].CR[14];
 256
 257         cr_data = XGI_Pr->XGINEWUB_CRT1Table[index].CR[8];
 258
 259         cr_data2 = XGI_Pr->XGINEWUB_CRT1Table[index].CR[9];
 260
 261         /* Vertical total */
 262         VT = (cr_data & 0xFF) | ((unsigned short) (cr_data2 & 0x01) << 8)
 263                         | ((unsigned short) (cr_data2 & 0x20) << 4)
 264                         | ((unsigned short) (sr_data & 0x01) << 10);
 265         A = VT + 2;
 266
 267         /* cr_data = XGI_Pr->XGINEWUB_CRT1Table[index].CR[10]; */
 268
 269         /* Vertical display enable end */
 270         /*
 271         VDE = (cr_data & 0xff) |
 272                 ((unsigned short) (cr_data2 & 0x02) << 7) |
 273                 ((unsigned short) (cr_data2 & 0x40) << 3) |
 274                 ((unsigned short) (sr_data & 0x02) << 9);
 275         */
 276         VDE = XGI_Pr->RefIndex[RefreshRateTableIndex].YRes - 1;
 277         E = VDE + 1;
 278
 279         cr_data = XGI_Pr->XGINEWUB_CRT1Table[index].CR[10];
 280
 281         /* Vertical retrace (=sync) start */
 282         VRS = (cr_data & 0xff) | ((unsigned short) (cr_data2 & 0x04) << 6)
 283                         | ((unsigned short) (cr_data2 & 0x80) << 2)
 284                         | ((unsigned short) (sr_data & 0x08) << 7);
 285         F = VRS + 1 - E;
 286
 287         cr_data = XGI_Pr->XGINEWUB_CRT1Table[index].CR[12];
 288
 289         cr_data3 = (XGI_Pr->XGINEWUB_CRT1Table[index].CR[14] & 0x80) << 5;
 290
 291         /* Vertical blank start */
 292         VBS = (cr_data & 0xff) | ((unsigned short) (cr_data2 & 0x08) << 5)
 293                         | ((unsigned short) (cr_data3 & 0x20) << 4)
 294                         | ((unsigned short) (sr_data & 0x04) << 8);
 295
 296         cr_data = XGI_Pr->XGINEWUB_CRT1Table[index].CR[13];
 297
 298         /* Vertical blank end */
 299         VBE = (cr_data & 0xff) | ((unsigned short) (sr_data & 0x10) << 4);
 300         temp = VBE - ((E - 1) & 511);
 301         B = (temp > 0) ? temp : (temp + 512);
 302
 303         cr_data = XGI_Pr->XGINEWUB_CRT1Table[index].CR[11];
 304
 305         /* Vertical retrace (=sync) end */
 306         VRE = (cr_data & 0x0f) | ((sr_data & 0x20) >> 1);
 307         temp = VRE - ((E + F - 1) & 31);
 308         C = (temp > 0) ? temp : (temp + 32);
 309
 310         D = B - F - C;
 311
 312         *upper_margin = D;
 313         *lower_margin = F;
 314         *vsync_len = C;
 315
 316         if (XGI_Pr->RefIndex[RefreshRateTableIndex].Ext_InfoFlag & 0x8000)
 317                 *sync &= ~FB_SYNC_VERT_HIGH_ACT;
 318         else
 319                 *sync |= FB_SYNC_VERT_HIGH_ACT;
 320
 321         if (XGI_Pr->RefIndex[RefreshRateTableIndex].Ext_InfoFlag & 0x4000)
 322                 *sync &= ~FB_SYNC_HOR_HIGH_ACT;
 323         else
 324                 *sync |= FB_SYNC_HOR_HIGH_ACT;
 325
 326         *vmode = FB_VMODE_NONINTERLACED;
 327         if (XGI_Pr->RefIndex[RefreshRateTableIndex].Ext_InfoFlag & 0x0080)
 328                 *vmode = FB_VMODE_INTERLACED;
 329         else {
 330                 j = 0;
 331                 while (XGI_Pr->EModeIDTable[j].Ext_ModeID != 0xff) {
 332                         if (XGI_Pr->EModeIDTable[j].Ext_ModeID ==
 333                             XGI_Pr->RefIndex[RefreshRateTableIndex].ModeID) {
 334                                 if (XGI_Pr->EModeIDTable[j].Ext_ModeFlag &
 335                                     DoubleScanMode) {
 336                                         *vmode = FB_VMODE_DOUBLE;
 337                                 }
 338                                 break;
 339                         }
 340                         j++;
 341                 }
 342         }
 343
 344         return 1;
 345 }
 346
 347 static void XGIRegInit(struct vb_device_info *XGI_Pr, unsigned long BaseAddr)
 348 {
 349         XGI_Pr->P3c4 = BaseAddr + 0x14;
 350         XGI_Pr->P3d4 = BaseAddr + 0x24;
 351         XGI_Pr->P3c0 = BaseAddr + 0x10;
 352         XGI_Pr->P3ce = BaseAddr + 0x1e;
 353         XGI_Pr->P3c2 = BaseAddr + 0x12;
 354         XGI_Pr->P3ca = BaseAddr + 0x1a;
 355         XGI_Pr->P3c6 = BaseAddr + 0x16;
 356         XGI_Pr->P3c7 = BaseAddr + 0x17;
 357         XGI_Pr->P3c8 = BaseAddr + 0x18;
 358         XGI_Pr->P3c9 = BaseAddr + 0x19;
 359         XGI_Pr->P3da = BaseAddr + 0x2A;
 360         /* Digital video interface registers (LCD) */
 361         XGI_Pr->Part1Port = BaseAddr + SIS_CRT2_PORT_04;
 362         /* 301 TV Encoder registers */
 363         XGI_Pr->Part2Port = BaseAddr + SIS_CRT2_PORT_10;
 364         /* 301 Macrovision registers */
 365         XGI_Pr->Part3Port = BaseAddr + SIS_CRT2_PORT_12;
 366         /* 301 VGA2 (and LCD) registers */
 367         XGI_Pr->Part4Port = BaseAddr + SIS_CRT2_PORT_14;
 368         /* 301 palette address port registers */
 369         XGI_Pr->Part5Port = BaseAddr + SIS_CRT2_PORT_14 + 2;
 370
 371 }
 372
 373 /* ------------------ Internal helper routines ----------------- */
 374
 375 static int XGIfb_GetXG21DefaultLVDSModeIdx(struct xgifb_video_info *xgifb_info)
 376 {
 377
 378         int found_mode = 0;
 379         int XGIfb_mode_idx = 0;
 380
 381         found_mode = 0;
 382         while ((XGIbios_mode[XGIfb_mode_idx].mode_no != 0)
 383                         && (XGIbios_mode[XGIfb_mode_idx].xres
 384                                         <= xgifb_info->lvds_data.LVDSHDE)) {
 385                 if ((XGIbios_mode[XGIfb_mode_idx].xres
 386                                 == xgifb_info->lvds_data.LVDSHDE)
 387                                 && (XGIbios_mode[XGIfb_mode_idx].yres
 388                                         == xgifb_info->lvds_data.LVDSVDE)
 389                                 && (XGIbios_mode[XGIfb_mode_idx].bpp == 8)) {
 390                         found_mode = 1;
 391                         break;
 392                 }
 393                 XGIfb_mode_idx++;
 394         }
 395         if (!found_mode)
 396                 XGIfb_mode_idx = -1;
 397
 398         return XGIfb_mode_idx;
 399 }
 400
 401 static void XGIfb_search_mode(struct xgifb_video_info *xgifb_info,
 402                               const char *name)
 403 {
 404         int i = 0, j = 0, l;
 405
 406         while (XGIbios_mode[i].mode_no != 0) {
 407                 l = min(strlen(name), strlen(XGIbios_mode[i].name));
 408                 if (!strncmp(name, XGIbios_mode[i].name, l)) {
 409                         xgifb_info->mode_idx = i;
 410                         j = 1;
 411                         break;
 412                 }
 413                 i++;
 414         }
 415         if (!j)
 416                 pr_info("Invalid mode '%s'\n", name);
 417 }
 418
 419 static void XGIfb_search_vesamode(struct xgifb_video_info *xgifb_info,
 420                                   unsigned int vesamode)
 421 {
 422         int i = 0, j = 0;
 423
 424         if (vesamode == 0)
 425                 goto invalid;
 426
 427         vesamode &= 0x1dff; /* Clean VESA mode number from other flags */
 428
 429         while (XGIbios_mode[i].mode_no != 0) {
 430                 if ((XGIbios_mode[i].vesa_mode_no_1 == vesamode) ||
 431                     (XGIbios_mode[i].vesa_mode_no_2 == vesamode)) {
 432                         xgifb_info->mode_idx = i;
 433                         j = 1;
 434                         break;
 435                 }
 436                 i++;
 437         }
 438
 439 invalid:
 440         if (!j)
 441                 pr_info("Invalid VESA mode 0x%x'\n", vesamode);
 442 }
 443
 444 static int XGIfb_validate_mode(struct xgifb_video_info *xgifb_info, int myindex)
 445 {
 446         u16 xres, yres;
 447         struct xgi_hw_device_info *hw_info = &xgifb_info->hw_info;
 448
 449         if (xgifb_info->chip == XG21) {
 450                 if (xgifb_info->display2 == XGIFB_DISP_LCD) {
 451                         xres = xgifb_info->lvds_data.LVDSHDE;
 452                         yres = xgifb_info->lvds_data.LVDSVDE;
 453                         if (XGIbios_mode[myindex].xres > xres)
 454                                 return -1;
 455                         if (XGIbios_mode[myindex].yres > yres)
 456                                 return -1;
 457                         if ((XGIbios_mode[myindex].xres < xres) &&
 458                             (XGIbios_mode[myindex].yres < yres)) {
 459                                 if (XGIbios_mode[myindex].bpp > 8)
 460                                         return -1;
 461                         }
 462
 463                 }
 464                 return myindex;
 465
 466         }
 467
 468         /* FIXME: for now, all is valid on XG27 */
 469         if (xgifb_info->chip == XG27)
 470                 return myindex;
 471
 472         if (!(XGIbios_mode[myindex].chipset & MD_XGI315))
 473                 return -1;
 474
 475         switch (xgifb_info->display2) {
 476         case XGIFB_DISP_LCD:
 477                 switch (hw_info->ulCRT2LCDType) {
 478                 case LCD_640x480:
 479                         xres = 640;
 480                         yres = 480;
 481                         break;
 482                 case LCD_800x600:
 483                         xres = 800;
 484                         yres = 600;
 485                         break;
 486                 case LCD_1024x600:
 487                         xres = 1024;
 488                         yres = 600;
 489                         break;
 490                 case LCD_1024x768:
 491                         xres = 1024;
 492                         yres = 768;
 493                         break;
 494                 case LCD_1152x768:
 495                         xres = 1152;
 496                         yres = 768;
 497                         break;
 498                 case LCD_1280x960:
 499                         xres = 1280;
 500                         yres = 960;
 501                         break;
 502                 case LCD_1280x768:
 503                         xres = 1280;
 504                         yres = 768;
 505                         break;
 506                 case LCD_1280x1024:
 507                         xres = 1280;
 508                         yres = 1024;
 509                         break;
 510                 case LCD_1400x1050:
 511                         xres = 1400;
 512                         yres = 1050;
 513                         break;
 514                 case LCD_1600x1200:
 515                         xres = 1600;
 516                         yres = 1200;
 517                         break;
 518                 default:
 519                         xres = 0;
 520                         yres = 0;
 521                         break;
 522                 }
 523                 if (XGIbios_mode[myindex].xres > xres)
 524                         return -1;
 525                 if (XGIbios_mode[myindex].yres > yres)
 526                         return -1;
 527                 if ((hw_info->ulExternalChip == 0x01) || /* LVDS */
 528                     (hw_info->ulExternalChip == 0x05)) { /* LVDS+Chrontel */
 529                         switch (XGIbios_mode[myindex].xres) {
 530                         case 512:
 531                                 if (XGIbios_mode[myindex].yres != 512)
 532                                         return -1;
 533                                 if (hw_info->ulCRT2LCDType == LCD_1024x600)
 534                                         return -1;
 535                                 break;
 536                         case 640:
 537                                 if ((XGIbios_mode[myindex].yres != 400)
 538                                                 && (XGIbios_mode[myindex].yres
 539                                                                 != 480))
 540                                         return -1;
 541                                 break;
 542                         case 800:
 543                                 if (XGIbios_mode[myindex].yres != 600)
 544                                         return -1;
 545                                 break;
 546                         case 1024:
 547                                 if ((XGIbios_mode[myindex].yres != 600) &&
 548                                     (XGIbios_mode[myindex].yres != 768))
 549                                         return -1;
 550                                 if ((XGIbios_mode[myindex].yres == 600) &&
 551                                     (hw_info->ulCRT2LCDType != LCD_1024x600))
 552                                         return -1;
 553                                 break;
 554                         case 1152:
 555                                 if ((XGIbios_mode[myindex].yres) != 768)
 556                                         return -1;
 557                                 if (hw_info->ulCRT2LCDType != LCD_1152x768)
 558                                         return -1;
 559                                 break;
 560                         case 1280:
 561                                 if ((XGIbios_mode[myindex].yres != 768) &&
 562                                     (XGIbios_mode[myindex].yres != 1024))
 563                                         return -1;
 564                                 if ((XGIbios_mode[myindex].yres == 768) &&
 565                                     (hw_info->ulCRT2LCDType != LCD_1280x768))
 566                                         return -1;
 567                                 break;
 568                         case 1400:
 569                                 if (XGIbios_mode[myindex].yres != 1050)
 570                                         return -1;
 571                                 break;
 572                         case 1600:
 573                                 if (XGIbios_mode[myindex].yres != 1200)
 574                                         return -1;
 575                                 break;
 576                         default:
 577                                 return -1;
 578                         }
 579                 } else {
 580                         switch (XGIbios_mode[myindex].xres) {
 581                         case 512:
 582                                 if (XGIbios_mode[myindex].yres != 512)
 583                                         return -1;
 584                                 break;
 585                         case 640:
 586                                 if ((XGIbios_mode[myindex].yres != 400) &&
 587                                     (XGIbios_mode[myindex].yres != 480))
 588                                         return -1;
 589                                 break;
 590                         case 800:
 591                                 if (XGIbios_mode[myindex].yres != 600)
 592                                         return -1;
 593                                 break;
 594                         case 1024:
 595                                 if (XGIbios_mode[myindex].yres != 768)
 596                                         return -1;
 597                                 break;
 598                         case 1280:
 599                                 if ((XGIbios_mode[myindex].yres != 960) &&
 600                                     (XGIbios_mode[myindex].yres != 1024))
 601                                         return -1;
 602                                 if (XGIbios_mode[myindex].yres == 960) {
 603                                         if (hw_info->ulCRT2LCDType ==
 604                                             LCD_1400x1050)
 605                                                 return -1;
 606                                 }
 607                                 break;
 608                         case 1400:
 609                                 if (XGIbios_mode[myindex].yres != 1050)
 610                                         return -1;
 611                                 break;
 612                         case 1600:
 613                                 if (XGIbios_mode[myindex].yres != 1200)
 614                                         return -1;
 615                                 break;
 616                         default:
 617                                 return -1;
 618                         }
 619                 }
 620                 break;
 621         case XGIFB_DISP_TV:
 622                 switch (XGIbios_mode[myindex].xres) {
 623                 case 512:
 624                 case 640:
 625                 case 800:
 626                         break;
 627                 case 720:
 628                         if (xgifb_info->TV_type == TVMODE_NTSC) {
 629                                 if (XGIbios_mode[myindex].yres != 480)
 630                                         return -1;
 631                         } else if (xgifb_info->TV_type == TVMODE_PAL) {
 632                                 if (XGIbios_mode[myindex].yres != 576)
 633                                         return -1;
 634                         }
 635                         /*  TW: LVDS/CHRONTEL does not support 720 */
 636                         if (xgifb_info->hasVB == HASVB_LVDS_CHRONTEL ||
 637                             xgifb_info->hasVB == HASVB_CHRONTEL) {
 638                                 return -1;
 639                         }
 640                         break;
 641                 case 1024:
 642                         if (xgifb_info->TV_type == TVMODE_NTSC) {
 643                                 if (XGIbios_mode[myindex].bpp == 32)
 644                                         return -1;
 645                         }
 646                         break;
 647                 default:
 648                         return -1;
 649                 }
 650                 break;
 651         case XGIFB_DISP_CRT:
 652                 if (XGIbios_mode[myindex].xres > 1280)
 653                         return -1;
 654                 break;
 655         case XGIFB_DISP_NONE:
 656                 break;
 657         }
 658         return myindex;
 659
 660 }
 661
 662 static void XGIfb_search_crt2type(const char *name)
 663 {
 664         int i = 0;
 665
 666         if (name == NULL)
 667                 return;
 668
 669         while (XGI_crt2type[i].type_no != -1) {
 670                 if (!strcmp(name, XGI_crt2type[i].name)) {
 671                         XGIfb_crt2type = XGI_crt2type[i].type_no;
 672                         XGIfb_tvplug = XGI_crt2type[i].tvplug_no;
 673                         break;
 674                 }
 675                 i++;
 676         }
 677         if (XGIfb_crt2type < 0)
 678                 pr_info("Invalid CRT2 type: %s\n", name);
 679 }
 680
 681 static u8 XGIfb_search_refresh_rate(struct xgifb_video_info *xgifb_info,
 682                                     unsigned int rate)
 683 {
 684         u16 xres, yres;
 685         int i = 0;
 686
 687         xres = XGIbios_mode[xgifb_info->mode_idx].xres;
 688         yres = XGIbios_mode[xgifb_info->mode_idx].yres;
 689
 690         xgifb_info->rate_idx = 0;
 691         while ((XGIfb_vrate[i].idx != 0) && (XGIfb_vrate[i].xres <= xres)) {
 692                 if ((XGIfb_vrate[i].xres == xres) &&
 693                     (XGIfb_vrate[i].yres == yres)) {
 694                         if (XGIfb_vrate[i].refresh == rate) {
 695                                 xgifb_info->rate_idx = XGIfb_vrate[i].idx;
 696                                 break;
 697                         } else if (XGIfb_vrate[i].refresh > rate) {
 698                                 if ((XGIfb_vrate[i].refresh - rate) <= 3) {
 699                                         DPRINTK("XGIfb: Adjusting rate from %d up to %d\n",
 700                                                 rate, XGIfb_vrate[i].refresh);
 701                                         xgifb_info->rate_idx =
 702                                                 XGIfb_vrate[i].idx;
 703                                         xgifb_info->refresh_rate =
 704                                                 XGIfb_vrate[i].refresh;
 705                                 } else if (((rate - XGIfb_vrate[i - 1].refresh)
 706                                                 <= 2) && (XGIfb_vrate[i].idx
 707                                                 != 1)) {
 708                                         DPRINTK("XGIfb: Adjusting rate from %d down to %d\n",
 709                                                 rate, XGIfb_vrate[i-1].refresh);
 710                                         xgifb_info->rate_idx =
 711                                                 XGIfb_vrate[i - 1].idx;
 712                                         xgifb_info->refresh_rate =
 713                                                 XGIfb_vrate[i - 1].refresh;
 714                                 }
 715                                 break;
 716                         } else if ((rate - XGIfb_vrate[i].refresh) <= 2) {
 717                                 DPRINTK("XGIfb: Adjusting rate from %d down to %d\n",
 718                                         rate, XGIfb_vrate[i].refresh);
 719                                 xgifb_info->rate_idx = XGIfb_vrate[i].idx;
 720                                 break;
 721                         }
 722                 }
 723                 i++;
 724         }
 725         if (xgifb_info->rate_idx > 0) {
 726                 return xgifb_info->rate_idx;
 727         } else {
 728                 pr_info("Unsupported rate %d for %dx%d\n",
 729                        rate, xres, yres);
 730                 return 0;
 731         }
 732 }
 733
 734 static void XGIfb_search_tvstd(const char *name)
 735 {
 736         int i = 0;
 737
 738         if (name == NULL)
 739                 return;
 740
 741         while (XGI_tvtype[i].type_no != -1) {
 742                 if (!strcmp(name, XGI_tvtype[i].name)) {
 743                         XGIfb_tvmode = XGI_tvtype[i].type_no;
 744                         break;
 745                 }
 746                 i++;
 747         }
 748 }
 749
 750 /* ----------- FBDev related routines for all series ----------- */
 751
 752 static void XGIfb_bpp_to_var(struct xgifb_video_info *xgifb_info,
 753                              struct fb_var_screeninfo *var)
 754 {
 755         switch (var->bits_per_pixel) {
 756         case 8:
 757                 var->red.offset = var->green.offset = var->blue.offset = 0;
 758                 var->red.length = var->green.length = var->blue.length = 6;
 759                 xgifb_info->video_cmap_len = 256;
 760                 break;
 761         case 16:
 762                 var->red.offset = 11;
 763                 var->red.length = 5;
 764                 var->green.offset = 5;
 765                 var->green.length = 6;
 766                 var->blue.offset = 0;
 767                 var->blue.length = 5;
 768                 var->transp.offset = 0;
 769                 var->transp.length = 0;
 770                 xgifb_info->video_cmap_len = 16;
 771                 break;
 772         case 32:
 773                 var->red.offset = 16;
 774                 var->red.length = 8;
 775                 var->green.offset = 8;
 776                 var->green.length = 8;
 777                 var->blue.offset = 0;
 778                 var->blue.length = 8;
 779                 var->transp.offset = 24;
 780                 var->transp.length = 8;
 781                 xgifb_info->video_cmap_len = 16;
 782                 break;
 783         }
 784 }
 785
 786 /* --------------------- SetMode routines ------------------------- */
 787
 788 static void XGIfb_pre_setmode(struct xgifb_video_info *xgifb_info)
 789 {
 790         u8 cr30 = 0, cr31 = 0;
 791
 792         cr31 = xgifb_reg_get(XGICR, 0x31);
 793         cr31 &= ~0x60;
 794
 795         switch (xgifb_info->display2) {
 796         case XGIFB_DISP_CRT:
 797                 cr30 = (SIS_VB_OUTPUT_CRT2 | SIS_SIMULTANEOUS_VIEW_ENABLE);
 798                 cr31 |= SIS_DRIVER_MODE;
 799                 break;
 800         case XGIFB_DISP_LCD:
 801                 cr30 = (SIS_VB_OUTPUT_LCD | SIS_SIMULTANEOUS_VIEW_ENABLE);
 802                 cr31 |= SIS_DRIVER_MODE;
 803                 break;
 804         case XGIFB_DISP_TV:
 805                 if (xgifb_info->TV_type == TVMODE_HIVISION)
 806                         cr30 = (SIS_VB_OUTPUT_HIVISION
 807                                         | SIS_SIMULTANEOUS_VIEW_ENABLE);
 808                 else if (xgifb_info->TV_plug == TVPLUG_SVIDEO)
 809                         cr30 = (SIS_VB_OUTPUT_SVIDEO
 810                                         | SIS_SIMULTANEOUS_VIEW_ENABLE);
 811                 else if (xgifb_info->TV_plug == TVPLUG_COMPOSITE)
 812                         cr30 = (SIS_VB_OUTPUT_COMPOSITE
 813                                         | SIS_SIMULTANEOUS_VIEW_ENABLE);
 814                 else if (xgifb_info->TV_plug == TVPLUG_SCART)
 815                         cr30 = (SIS_VB_OUTPUT_SCART
 816                                         | SIS_SIMULTANEOUS_VIEW_ENABLE);
 817                 cr31 |= SIS_DRIVER_MODE;
 818
 819                 if (XGIfb_tvmode == 1 || xgifb_info->TV_type == TVMODE_PAL)
 820                         cr31 |= 0x01;
 821                 else
 822                         cr31 &= ~0x01;
 823                 break;
 824         default: /* disable CRT2 */
 825                 cr30 = 0x00;
 826                 cr31 |= (SIS_DRIVER_MODE | SIS_VB_OUTPUT_DISABLE);
 827         }
 828
 829         xgifb_reg_set(XGICR, IND_XGI_SCRATCH_REG_CR30, cr30);
 830         xgifb_reg_set(XGICR, IND_XGI_SCRATCH_REG_CR31, cr31);
 831         xgifb_reg_set(XGICR, IND_XGI_SCRATCH_REG_CR33,
 832                                                 (xgifb_info->rate_idx & 0x0F));
 833 }
 834
 835 static void XGIfb_post_setmode(struct xgifb_video_info *xgifb_info)
 836 {
 837         u8 reg;
 838         unsigned char doit = 1;
 839         /*
 840         xgifb_reg_set(XGISR,IND_SIS_PASSWORD,SIS_PASSWORD);
 841         xgifb_reg_set(XGICR, 0x13, 0x00);
 842         xgifb_reg_and_or(XGISR,0x0E, 0xF0, 0x01);
 843         *test*
 844         */
 845         if (xgifb_info->video_bpp == 8) {
 846                 /* TW: We can't switch off CRT1 on LVDS/Chrontel
 847                  * in 8bpp Modes */
 848                 if ((xgifb_info->hasVB == HASVB_LVDS) ||
 849                     (xgifb_info->hasVB == HASVB_LVDS_CHRONTEL)) {
 850                         doit = 0;
 851                 }
 852                 /* TW: We can't switch off CRT1 on 301B-DH
 853                  * in 8bpp Modes if using LCD */
 854                 if (xgifb_info->display2 == XGIFB_DISP_LCD)
 855                         doit = 0;
 856         }
 857
 858         /* TW: We can't switch off CRT1 if bridge is in slave mode */
 859         if (xgifb_info->hasVB != HASVB_NONE) {
 860                 reg = xgifb_reg_get(XGIPART1, 0x00);
 861
 862                 if ((reg & 0x50) == 0x10)
 863                         doit = 0;
 864
 865         } else {
 866                 XGIfb_crt1off = 0;
 867         }
 868
 869         reg = xgifb_reg_get(XGICR, 0x17);
 870         if ((XGIfb_crt1off) && (doit))
 871                 reg &= ~0x80;
 872         else
 873                 reg |= 0x80;
 874         xgifb_reg_set(XGICR, 0x17, reg);
 875
 876         xgifb_reg_and(XGISR, IND_SIS_RAMDAC_CONTROL, ~0x04);
 877
 878         if (xgifb_info->display2 == XGIFB_DISP_TV &&
 879             xgifb_info->hasVB == HASVB_301) {
 880
 881                 reg = xgifb_reg_get(XGIPART4, 0x01);
 882
 883                 if (reg < 0xB0) { /* Set filter for XGI301 */
 884                         int filter_tb;
 885
 886                         switch (xgifb_info->video_width) {
 887                         case 320:
 888                                 filter_tb = (xgifb_info->TV_type ==
 889                                              TVMODE_NTSC) ? 4 : 12;
 890                                 break;
 891                         case 640:
 892                                 filter_tb = (xgifb_info->TV_type ==
 893                                              TVMODE_NTSC) ? 5 : 13;
 894                                 break;
 895                         case 720:
 896                                 filter_tb = (xgifb_info->TV_type ==
 897                                              TVMODE_NTSC) ? 6 : 14;
 898                                 break;
 899                         case 800:
 900                                 filter_tb = (xgifb_info->TV_type ==
 901                                              TVMODE_NTSC) ? 7 : 15;
 902                                 break;
 903                         default:
 904                                 filter_tb = 0;
 905                                 filter = -1;
 906                                 break;
 907                         }
 908                         xgifb_reg_or(XGIPART1,
 909                                      SIS_CRT2_WENABLE_315,
 910                                      0x01);
 911
 912                         if (xgifb_info->TV_type == TVMODE_NTSC) {
 913
 914                                 xgifb_reg_and(XGIPART2, 0x3a, 0x1f);
 915
 916                                 if (xgifb_info->TV_plug == TVPLUG_SVIDEO) {
 917
 918                                         xgifb_reg_and(XGIPART2, 0x30, 0xdf);
 919
 920                                 } else if (xgifb_info->TV_plug
 921                                                 == TVPLUG_COMPOSITE) {
 922
 923                                         xgifb_reg_or(XGIPART2, 0x30, 0x20);
 924
 925                                         switch (xgifb_info->video_width) {
 926                                         case 640:
 927                                                 xgifb_reg_set(XGIPART2,
 928                                                               0x35,
 929                                                               0xEB);
 930                                                 xgifb_reg_set(XGIPART2,
 931                                                               0x36,
 932                                                               0x04);
 933                                                 xgifb_reg_set(XGIPART2,
 934                                                               0x37,
 935                                                               0x25);
 936                                                 xgifb_reg_set(XGIPART2,
 937                                                               0x38,
 938                                                               0x18);
 939                                                 break;
 940                                         case 720:
 941                                                 xgifb_reg_set(XGIPART2,
 942                                                               0x35,
 943                                                               0xEE);
 944                                                 xgifb_reg_set(XGIPART2,
 945                                                               0x36,
 946                                                               0x0C);
 947                                                 xgifb_reg_set(XGIPART2,
 948                                                               0x37,
 949                                                               0x22);
 950                                                 xgifb_reg_set(XGIPART2,
 951                                                               0x38,
 952                                                               0x08);
 953                                                 break;
 954                                         case 800:
 955                                                 xgifb_reg_set(XGIPART2,
 956                                                               0x35,
 957                                                               0xEB);
 958                                                 xgifb_reg_set(XGIPART2,
 959                                                               0x36,
 960                                                               0x15);
 961                                                 xgifb_reg_set(XGIPART2,
 962                                                               0x37,
 963                                                               0x25);
 964                                                 xgifb_reg_set(XGIPART2,
 965                                                               0x38,
 966                                                               0xF6);
 967                                                 break;
 968                                         }
 969                                 }
 970
 971                         } else if (xgifb_info->TV_type == TVMODE_PAL) {
 972
 973                                 xgifb_reg_and(XGIPART2, 0x3A, 0x1F);
 974
 975                                 if (xgifb_info->TV_plug == TVPLUG_SVIDEO) {
 976
 977                                         xgifb_reg_and(XGIPART2, 0x30, 0xDF);
 978
 979                                 } else if (xgifb_info->TV_plug
 980                                                 == TVPLUG_COMPOSITE) {
 981
 982                                         xgifb_reg_or(XGIPART2, 0x30, 0x20);
 983
 984                                         switch (xgifb_info->video_width) {
 985                                         case 640:
 986                                                 xgifb_reg_set(XGIPART2,
 987                                                               0x35,
 988                                                               0xF1);
 989                                                 xgifb_reg_set(XGIPART2,
 990                                                               0x36,
 991                                                               0xF7);
 992                                                 xgifb_reg_set(XGIPART2,
 993                                                               0x37,
 994                                                               0x1F);
 995                                                 xgifb_reg_set(XGIPART2,
 996                                                               0x38,
 997                                                               0x32);
 998                                                 break;
 999                                         case 720:
1000                                                 xgifb_reg_set(XGIPART2,
1001                                                               0x35,
1002                                                               0xF3);
1003                                                 xgifb_reg_set(XGIPART2,
1004                                                               0x36,
1005                                                               0x00);
1006                                                 xgifb_reg_set(XGIPART2,
1007                                                               0x37,
1008                                                               0x1D);
1009                                                 xgifb_reg_set(XGIPART2,
1010                                                               0x38,
1011                                                               0x20);
1012                                                 break;
1013                                         case 800:
1014                                                 xgifb_reg_set(XGIPART2,
1015                                                               0x35,
1016                                                               0xFC);
1017                                                 xgifb_reg_set(XGIPART2,
1018                                                               0x36,
1019                                                               0xFB);
1020                                                 xgifb_reg_set(XGIPART2,
1021                                                               0x37,
1022                                                               0x14);
1023                                                 xgifb_reg_set(XGIPART2,
1024                                                               0x38,
1025                                                               0x2A);
1026                                                 break;
1027                                         }
1028                                 }
1029                         }
1030
1031                         if ((filter >= 0) && (filter <= 7)) {
1032                                 DPRINTK("FilterTable[%d]-%d: %02x %02x %02x %02x\n",
1033                                         filter_tb, filter,
1034                                         XGI_TV_filter[filter_tb].
1035                                                 filter[filter][0],
1036                                         XGI_TV_filter[filter_tb].
1037                                                 filter[filter][1],
1038                                         XGI_TV_filter[filter_tb].
1039                                                 filter[filter][2],
1040                                         XGI_TV_filter[filter_tb].
1041                                                 filter[filter][3]
1042                                 );
1043                                 xgifb_reg_set(
1044                                         XGIPART2,
1045                                         0x35,
1046                                         (XGI_TV_filter[filter_tb].
1047                                                 filter[filter][0]));
1048                                 xgifb_reg_set(
1049                                         XGIPART2,
1050                                         0x36,
1051                                         (XGI_TV_filter[filter_tb].
1052                                                 filter[filter][1]));
1053                                 xgifb_reg_set(
1054                                         XGIPART2,
1055                                         0x37,
1056                                         (XGI_TV_filter[filter_tb].
1057                                                 filter[filter][2]));
1058                                 xgifb_reg_set(
1059                                         XGIPART2,
1060                                         0x38,
1061                                         (XGI_TV_filter[filter_tb].
1062                                                 filter[filter][3]));
1063                         }
1064                 }
1065         }
1066 }
1067
1068 static int XGIfb_do_set_var(struct fb_var_screeninfo *var, int isactive,
1069                 struct fb_info *info)
1070 {
1071         struct xgifb_video_info *xgifb_info = info->par;
1072         struct xgi_hw_device_info *hw_info = &xgifb_info->hw_info;
1073         unsigned int htotal = var->left_margin + var->xres + var->right_margin
1074                         + var->hsync_len;
1075         unsigned int vtotal = var->upper_margin + var->yres + var->lower_margin
1076                         + var->vsync_len;
1077 #if defined(__powerpc__)
1078         u8 cr_data;
1079 #endif
1080         unsigned int drate = 0, hrate = 0;
1081         int found_mode = 0;
1082         int old_mode;
1083         /* unsigned char reg, reg1; */
1084
1085         DEBUGPRN("Inside do_set_var");
1086         /* printk(KERN_DEBUG "XGIfb:var->yres=%d, var->upper_margin=%d, var->lower_margin=%d, var->vsync_len=%d\n", var->yres, var->upper_margin, var->lower_margin, var->vsync_len); */
1087
1088         info->var.xres_virtual = var->xres_virtual;
1089         info->var.yres_virtual = var->yres_virtual;
1090         info->var.bits_per_pixel = var->bits_per_pixel;
1091
1092         if ((var->vmode & FB_VMODE_MASK) == FB_VMODE_NONINTERLACED)
1093                 vtotal <<= 1;
1094         else if ((var->vmode & FB_VMODE_MASK) == FB_VMODE_DOUBLE)
1095                 vtotal <<= 2;
1096         else if ((var->vmode & FB_VMODE_MASK) == FB_VMODE_INTERLACED) {
1097                 /* vtotal <<= 1; */
1098                 /* var->yres <<= 1; */
1099         }
1100
1101         if (!htotal || !vtotal) {
1102                 DPRINTK("XGIfb: Invalid 'var' information\n");
1103                 return -EINVAL;
1104         } pr_debug("var->pixclock=%d, htotal=%d, vtotal=%d\n",
1105                         var->pixclock, htotal, vtotal);
1106
1107         if (var->pixclock && htotal && vtotal) {
1108                 drate = 1000000000 / var->pixclock;
1109                 hrate = (drate * 1000) / htotal;
1110                 xgifb_info->refresh_rate = (unsigned int) (hrate * 2
1111                                 / vtotal);
1112         } else {
1113                 xgifb_info->refresh_rate = 60;
1114         }
1115
1116         pr_debug("Change mode to %dx%dx%d-%dHz\n",
1117                var->xres,
1118                var->yres,
1119                var->bits_per_pixel,
1120                xgifb_info->refresh_rate);
1121
1122         old_mode = xgifb_info->mode_idx;
1123         xgifb_info->mode_idx = 0;
1124
1125         while ((XGIbios_mode[xgifb_info->mode_idx].mode_no != 0) &&
1126                (XGIbios_mode[xgifb_info->mode_idx].xres <= var->xres)) {
1127                 if ((XGIbios_mode[xgifb_info->mode_idx].xres == var->xres) &&
1128                     (XGIbios_mode[xgifb_info->mode_idx].yres == var->yres) &&
1129                     (XGIbios_mode[xgifb_info->mode_idx].bpp
1130                                                 == var->bits_per_pixel)) {
1131                         found_mode = 1;
1132                         break;
1133                 }
1134                 xgifb_info->mode_idx++;
1135         }
1136
1137         if (found_mode)
1138                 xgifb_info->mode_idx = XGIfb_validate_mode(xgifb_info,
1139                                                         xgifb_info->mode_idx);
1140         else
1141                 xgifb_info->mode_idx = -1;
1142
1143         if (xgifb_info->mode_idx < 0) {
1144                 pr_err("Mode %dx%dx%d not supported\n",
1145                        var->xres, var->yres, var->bits_per_pixel);
1146                 xgifb_info->mode_idx = old_mode;
1147                 return -EINVAL;
1148         }
1149
1150         if (XGIfb_search_refresh_rate(xgifb_info,
1151                                       xgifb_info->refresh_rate) == 0) {
1152                 xgifb_info->rate_idx =
1153                         XGIbios_mode[xgifb_info->mode_idx].rate_idx;
1154                 xgifb_info->refresh_rate = 60;
1155         }
1156
1157         if (isactive) {
1158
1159                 XGIfb_pre_setmode(xgifb_info);
1160                 if (XGISetModeNew(xgifb_info, hw_info,
1161                                   XGIbios_mode[xgifb_info->mode_idx].mode_no)
1162                                         == 0) {
1163                         pr_err("Setting mode[0x%x] failed\n",
1164                                XGIbios_mode[xgifb_info->mode_idx].mode_no);
1165                         return -EINVAL;
1166                 }
1167                 info->fix.line_length = ((info->var.xres_virtual
1168                                 * info->var.bits_per_pixel) >> 6);
1169
1170                 xgifb_reg_set(XGISR, IND_SIS_PASSWORD, SIS_PASSWORD);
1171
1172                 xgifb_reg_set(XGICR, 0x13, (info->fix.line_length & 0x00ff));
1173                 xgifb_reg_set(XGISR,
1174                               0x0E,
1175                               (info->fix.line_length & 0xff00) >> 8);
1176
1177                 XGIfb_post_setmode(xgifb_info);
1178
1179                 DPRINTK("XGIfb: Set new mode: %dx%dx%d-%d\n",
1180                                 XGIbios_mode[xgifb_info->mode_idx].xres,
1181                                 XGIbios_mode[xgifb_info->mode_idx].yres,
1182                                 XGIbios_mode[xgifb_info->mode_idx].bpp,
1183                                 xgifb_info->refresh_rate);
1184
1185                 xgifb_info->video_bpp = XGIbios_mode[xgifb_info->mode_idx].bpp;
1186                 xgifb_info->video_vwidth = info->var.xres_virtual;
1187                 xgifb_info->video_width =
1188                         XGIbios_mode[xgifb_info->mode_idx].xres;
1189                 xgifb_info->video_vheight = info->var.yres_virtual;
1190                 xgifb_info->video_height =
1191                         XGIbios_mode[xgifb_info->mode_idx].yres;
1192                 xgifb_info->org_x = xgifb_info->org_y = 0;
1193                 xgifb_info->video_linelength = info->var.xres_virtual
1194                                 * (xgifb_info->video_bpp >> 3);
1195                 switch (xgifb_info->video_bpp) {
1196                 case 8:
1197                         xgifb_info->DstColor = 0x0000;
1198                         xgifb_info->XGI310_AccelDepth = 0x00000000;
1199                         xgifb_info->video_cmap_len = 256;
1200 #if defined(__powerpc__)
1201                         cr_data = xgifb_reg_get(XGICR, 0x4D);
1202                         xgifb_reg_set(XGICR, 0x4D, (cr_data & 0xE0));
1203 #endif
1204                         break;
1205                 case 16:
1206                         xgifb_info->DstColor = 0x8000;
1207                         xgifb_info->XGI310_AccelDepth = 0x00010000;
1208 #if defined(__powerpc__)
1209                         cr_data = xgifb_reg_get(XGICR, 0x4D);
1210                         xgifb_reg_set(XGICR, 0x4D, ((cr_data & 0xE0) | 0x0B));
1211 #endif
1212                         xgifb_info->video_cmap_len = 16;
1213                         break;
1214                 case 32:
1215                         xgifb_info->DstColor = 0xC000;
1216                         xgifb_info->XGI310_AccelDepth = 0x00020000;
1217                         xgifb_info->video_cmap_len = 16;
1218 #if defined(__powerpc__)
1219                         cr_data = xgifb_reg_get(XGICR, 0x4D);
1220                         xgifb_reg_set(XGICR, 0x4D, ((cr_data & 0xE0) | 0x15));
1221 #endif
1222                         break;
1223                 default:
1224                         xgifb_info->video_cmap_len = 16;
1225                         pr_err("Unsupported depth %d",
1226                                xgifb_info->video_bpp);
1227                         break;
1228                 }
1229         }
1230         XGIfb_bpp_to_var(xgifb_info, var); /*update ARGB info*/
1231         DEBUGPRN("End of do_set_var");
1232
1233         dumpVGAReg();
1234         return 0;
1235 }
1236
1237 static int XGIfb_pan_var(struct fb_var_screeninfo *var, struct fb_info *info)
1238 {
1239         struct xgifb_video_info *xgifb_info = info->par;
1240         unsigned int base;
1241
1242         /* printk("Inside pan_var"); */
1243
1244         base = var->yoffset * info->var.xres_virtual + var->xoffset;
1245
1246         /* calculate base bpp dep. */
1247         switch (info->var.bits_per_pixel) {
1248         case 16:
1249                 base >>= 1;
1250                 break;
1251         case 32:
1252                 break;
1253         case 8:
1254         default:
1255                 base >>= 2;
1256                 break;
1257         }
1258
1259         xgifb_reg_set(XGISR, IND_SIS_PASSWORD, SIS_PASSWORD);
1260
1261         xgifb_reg_set(XGICR, 0x0D, base & 0xFF);
1262         xgifb_reg_set(XGICR, 0x0C, (base >> 8) & 0xFF);
1263         xgifb_reg_set(XGISR, 0x0D, (base >> 16) & 0xFF);
1264         xgifb_reg_set(XGISR, 0x37, (base >> 24) & 0x03);
1265         xgifb_reg_and_or(XGISR, 0x37, 0xDF, (base >> 21) & 0x04);
1266
1267         if (xgifb_info->display2 != XGIFB_DISP_NONE) {
1268                 xgifb_reg_or(XGIPART1, SIS_CRT2_WENABLE_315, 0x01);
1269                 xgifb_reg_set(XGIPART1, 0x06, (base & 0xFF));
1270                 xgifb_reg_set(XGIPART1, 0x05, ((base >> 8) & 0xFF));
1271                 xgifb_reg_set(XGIPART1, 0x04, ((base >> 16) & 0xFF));
1272                 xgifb_reg_and_or(XGIPART1,
1273                                  0x02,
1274                                  0x7F,
1275                                  ((base >> 24) & 0x01) << 7);
1276         }
1277         /* printk("End of pan_var"); */
1278         return 0;
1279 }
1280
1281 static int XGIfb_open(struct fb_info *info, int user)
1282 {
1283         return 0;
1284 }
1285
1286 static int XGIfb_release(struct fb_info *info, int user)
1287 {
1288         return 0;
1289 }
1290
1291 static int XGIfb_get_cmap_len(const struct fb_var_screeninfo *var)
1292 {
1293         int rc = 16;
1294
1295         switch (var->bits_per_pixel) {
1296         case 8:
1297                 rc = 256;
1298                 break;
1299         case 16:
1300                 rc = 16;
1301                 break;
1302         case 32:
1303                 rc = 16;
1304                 break;
1305         }
1306         return rc;
1307 }
1308
1309 static int XGIfb_setcolreg(unsigned regno, unsigned red, unsigned green,
1310                 unsigned blue, unsigned transp, struct fb_info *info)
1311 {
1312         struct xgifb_video_info *xgifb_info = info->par;
1313
1314         if (regno >= XGIfb_get_cmap_len(&info->var))
1315                 return 1;
1316
1317         switch (info->var.bits_per_pixel) {
1318         case 8:
1319                 outb(regno, XGIDACA);
1320                 outb((red >> 10), XGIDACD);
1321                 outb((green >> 10), XGIDACD);
1322                 outb((blue >> 10), XGIDACD);
1323                 if (xgifb_info->display2 != XGIFB_DISP_NONE) {
1324                         outb(regno, XGIDAC2A);
1325                         outb((red >> 8), XGIDAC2D);
1326                         outb((green >> 8), XGIDAC2D);
1327                         outb((blue >> 8), XGIDAC2D);
1328                 }
1329                 break;
1330         case 16:
1331                 ((u32 *) (info->pseudo_palette))[regno] = ((red & 0xf800))
1332                                 | ((green & 0xfc00) >> 5) | ((blue & 0xf800)
1333                                 >> 11);
1334                 break;
1335         case 32:
1336                 red >>= 8;
1337                 green >>= 8;
1338                 blue >>= 8;
1339                 ((u32 *) (info->pseudo_palette))[regno] = (red << 16) | (green
1340                                 << 8) | (blue);
1341                 break;
1342         }
1343         return 0;
1344 }
1345
1346 /* ----------- FBDev related routines for all series ---------- */
1347
1348 static int XGIfb_get_fix(struct fb_fix_screeninfo *fix, int con,
1349                 struct fb_info *info)
1350 {
1351         struct xgifb_video_info *xgifb_info = info->par;
1352
1353         DEBUGPRN("inside get_fix");
1354         memset(fix, 0, sizeof(struct fb_fix_screeninfo));
1355
1356         fix->smem_start = xgifb_info->video_base;
1357
1358         fix->smem_len = xgifb_info->video_size;
1359
1360         fix->type = FB_TYPE_PACKED_PIXELS;
1361         fix->type_aux = 0;
1362         if (xgifb_info->video_bpp == 8)
1363                 fix->visual = FB_VISUAL_PSEUDOCOLOR;
1364         else
1365                 fix->visual = FB_VISUAL_DIRECTCOLOR;
1366         fix->xpanstep = 0;
1367         if (XGIfb_ypan)
1368                 fix->ypanstep = 1;
1369         fix->ywrapstep = 0;
1370         fix->line_length = xgifb_info->video_linelength;
1371         fix->mmio_start = xgifb_info->mmio_base;
1372         fix->mmio_len = xgifb_info->mmio_size;
1373         fix->accel = FB_ACCEL_SIS_XABRE;
1374
1375         DEBUGPRN("end of get_fix");
1376         return 0;
1377 }
1378
1379 static int XGIfb_set_par(struct fb_info *info)
1380 {
1381         int err;
1382
1383         /* printk("XGIfb: inside set_par\n"); */
1384         err = XGIfb_do_set_var(&info->var, 1, info);
1385         if (err)
1386                 return err;
1387         XGIfb_get_fix(&info->fix, -1, info);
1388         /* printk("XGIfb: end of set_par\n"); */
1389         return 0;
1390 }
1391
1392 static int XGIfb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
1393 {
1394         struct xgifb_video_info *xgifb_info = info->par;
1395         unsigned int htotal = var->left_margin + var->xres + var->right_margin
1396                         + var->hsync_len;
1397         unsigned int vtotal = 0;
1398         unsigned int drate = 0, hrate = 0;
1399         int found_mode = 0;
1400         int refresh_rate, search_idx;
1401
1402         DEBUGPRN("Inside check_var");
1403
1404         if ((var->vmode & FB_VMODE_MASK) == FB_VMODE_NONINTERLACED) {
1405                 vtotal = var->upper_margin + var->yres + var->lower_margin
1406                                 + var->vsync_len;
1407                 vtotal <<= 1;
1408         } else if ((var->vmode & FB_VMODE_MASK) == FB_VMODE_DOUBLE) {
1409                 vtotal = var->upper_margin + var->yres + var->lower_margin
1410                                 + var->vsync_len;
1411                 vtotal <<= 2;
1412         } else if ((var->vmode & FB_VMODE_MASK) == FB_VMODE_INTERLACED) {
1413                 vtotal = var->upper_margin + (var->yres / 2)
1414                                 + var->lower_margin + var->vsync_len;
1415         } else
1416                 vtotal = var->upper_margin + var->yres + var->lower_margin
1417                                 + var->vsync_len;
1418
1419         if (!(htotal) || !(vtotal))
1420                 XGIFAIL("XGIfb: no valid timing data");
1421
1422         if (var->pixclock && htotal && vtotal) {
1423                 drate = 1000000000 / var->pixclock;
1424                 hrate = (drate * 1000) / htotal;
1425                 xgifb_info->refresh_rate =
1426                         (unsigned int) (hrate * 2 / vtotal);
1427                 pr_debug(
1428                         "%s: pixclock = %d ,htotal=%d, vtotal=%d\n"
1429                         "%s: drate=%d, hrate=%d, refresh_rate=%d\n",
1430                         __func__, var->pixclock, htotal, vtotal,
1431                         __func__, drate, hrate, xgifb_info->refresh_rate);
1432         } else {
1433                 xgifb_info->refresh_rate = 60;
1434         }
1435
1436         /*
1437         if ((var->pixclock) && (htotal)) {
1438                 drate = 1E12 / var->pixclock;
1439                 hrate = drate / htotal;
1440                 refresh_rate = (unsigned int) (hrate / vtotal * 2 + 0.5);
1441         } else {
1442                 refresh_rate = 60;
1443         }
1444         */
1445         /* TW: Calculation wrong for 1024x600 - force it to 60Hz */
1446         if ((var->xres == 1024) && (var->yres == 600))
1447                 refresh_rate = 60;
1448
1449         search_idx = 0;
1450         while ((XGIbios_mode[search_idx].mode_no != 0) &&
1451                 (XGIbios_mode[search_idx].xres <= var->xres)) {
1452                 if ((XGIbios_mode[search_idx].xres == var->xres) &&
1453                         (XGIbios_mode[search_idx].yres == var->yres) &&
1454                         (XGIbios_mode[search_idx].bpp == var->bits_per_pixel)) {
1455                         if (XGIfb_validate_mode(xgifb_info, search_idx) > 0) {
1456                                 found_mode = 1;
1457                                 break;
1458                         }
1459                 }
1460                 search_idx++;
1461         }
1462
1463         if (!found_mode) {
1464
1465                 pr_err("%dx%dx%d is no valid mode\n",
1466                         var->xres, var->yres, var->bits_per_pixel);
1467                 search_idx = 0;
1468                 while (XGIbios_mode[search_idx].mode_no != 0) {
1469                         if ((var->xres <= XGIbios_mode[search_idx].xres) &&
1470                             (var->yres <= XGIbios_mode[search_idx].yres) &&
1471                             (var->bits_per_pixel ==
1472                              XGIbios_mode[search_idx].bpp)) {
1473                                 if (XGIfb_validate_mode(xgifb_info,
1474                                                         search_idx) > 0) {
1475                                         found_mode = 1;
1476                                         break;
1477                                 }
1478                         }
1479                         search_idx++;
1480                 }
1481                 if (found_mode) {
1482                         var->xres = XGIbios_mode[search_idx].xres;
1483                         var->yres = XGIbios_mode[search_idx].yres;
1484                         pr_debug("Adapted to mode %dx%dx%d\n",
1485                                 var->xres, var->yres, var->bits_per_pixel);
1486
1487                 } else {
1488                         pr_err("Failed to find similar mode to %dx%dx%d\n",
1489                                 var->xres, var->yres, var->bits_per_pixel);
1490                         return -EINVAL;
1491                 }
1492         }
1493
1494         /* TW: TODO: Check the refresh rate */
1495
1496         /* Adapt RGB settings */
1497         XGIfb_bpp_to_var(xgifb_info, var);
1498
1499         /* Sanity check for offsets */
1500         if (var->xoffset < 0)
1501                 var->xoffset = 0;
1502         if (var->yoffset < 0)
1503                 var->yoffset = 0;
1504
1505         if (!XGIfb_ypan) {
1506                 if (var->xres != var->xres_virtual)
1507                         var->xres_virtual = var->xres;
1508                 if (var->yres != var->yres_virtual)
1509                         var->yres_virtual = var->yres;
1510         } /* else { */
1511                 /* TW: Now patch yres_virtual if we use panning */
1512                 /* May I do this? */
1513                 /* var->yres_virtual = xgifb_info->heapstart /
1514                         (var->xres * (var->bits_per_pixel >> 3)); */
1515                 /* if (var->yres_virtual <= var->yres) { */
1516                 /* TW: Paranoia check */
1517                 /* var->yres_virtual = var->yres; */
1518                 /* } */
1519         /* } */
1520
1521         /* Truncate offsets to maximum if too high */
1522         if (var->xoffset > var->xres_virtual - var->xres)
1523                 var->xoffset = var->xres_virtual - var->xres - 1;
1524
1525         if (var->yoffset > var->yres_virtual - var->yres)
1526                 var->yoffset = var->yres_virtual - var->yres - 1;
1527
1528         /* Set everything else to 0 */
1529         var->red.msb_right =
1530         var->green.msb_right =
1531         var->blue.msb_right =
1532         var->transp.offset = var->transp.length = var->transp.msb_right = 0;
1533
1534         DEBUGPRN("end of check_var");
1535         return 0;
1536 }
1537
1538 static int XGIfb_pan_display(struct fb_var_screeninfo *var,
1539                 struct fb_info *info)
1540 {
1541         int err;
1542
1543         /* printk("\nInside pan_display:\n"); */
1544
1545         if (var->xoffset > (info->var.xres_virtual - info->var.xres))
1546                 return -EINVAL;
1547         if (var->yoffset > (info->var.yres_virtual - info->var.yres))
1548                 return -EINVAL;
1549
1550         if (var->vmode & FB_VMODE_YWRAP) {
1551                 if (var->yoffset < 0 || var->yoffset >= info->var.yres_virtual
1552                                 || var->xoffset)
1553                         return -EINVAL;
1554         } else {
1555                 if (var->xoffset + info->var.xres > info->var.xres_virtual
1556                                 || var->yoffset + info->var.yres
1557                                                 > info->var.yres_virtual)
1558                         return -EINVAL;
1559         }
1560         err = XGIfb_pan_var(var, info);
1561         if (err < 0)
1562                 return err;
1563
1564         info->var.xoffset = var->xoffset;
1565         info->var.yoffset = var->yoffset;
1566         if (var->vmode & FB_VMODE_YWRAP)
1567                 info->var.vmode |= FB_VMODE_YWRAP;
1568         else
1569                 info->var.vmode &= ~FB_VMODE_YWRAP;
1570
1571         /* printk("End of pan_display\n"); */
1572         return 0;
1573 }
1574
1575 static int XGIfb_blank(int blank, struct fb_info *info)
1576 {
1577         struct xgifb_video_info *xgifb_info = info->par;
1578         u8 reg;
1579
1580         reg = xgifb_reg_get(XGICR, 0x17);
1581
1582         if (blank > 0)
1583                 reg &= 0x7f;
1584         else
1585                 reg |= 0x80;
1586
1587         xgifb_reg_set(XGICR, 0x17, reg);
1588         xgifb_reg_set(XGISR, 0x00, 0x01); /* Synchronous Reset */
1589         xgifb_reg_set(XGISR, 0x00, 0x03); /* End Reset */
1590         return 0;
1591 }
1592
1593 static struct fb_ops XGIfb_ops = {
1594         .owner = THIS_MODULE,
1595         .fb_open = XGIfb_open,
1596         .fb_release = XGIfb_release,
1597         .fb_check_var = XGIfb_check_var,
1598         .fb_set_par = XGIfb_set_par,
1599         .fb_setcolreg = XGIfb_setcolreg,
1600         .fb_pan_display = XGIfb_pan_display,
1601         .fb_blank = XGIfb_blank,
1602         .fb_fillrect = cfb_fillrect,
1603         .fb_copyarea = cfb_copyarea,
1604         .fb_imageblit = cfb_imageblit,
1605         /* .fb_mmap = XGIfb_mmap, */
1606 };
1607
1608 /* ---------------- Chip generation dependent routines ---------------- */
1609
1610 /* for XGI 315/550/650/740/330 */
1611
1612 static int XGIfb_get_dram_size(struct xgifb_video_info *xgifb_info)
1613 {
1614
1615         u8 ChannelNum, tmp;
1616         u8 reg = 0;
1617
1618         /* xorg driver sets 32MB * 1 channel */
1619         if (xgifb_info->chip == XG27)
1620                 xgifb_reg_set(XGISR, IND_SIS_DRAM_SIZE, 0x51);
1621
1622         reg = xgifb_reg_get(XGISR, IND_SIS_DRAM_SIZE);
1623         switch ((reg & XGI_DRAM_SIZE_MASK) >> 4) {
1624         case XGI_DRAM_SIZE_1MB:
1625                 xgifb_info->video_size = 0x100000;
1626                 break;
1627         case XGI_DRAM_SIZE_2MB:
1628                 xgifb_info->video_size = 0x200000;
1629                 break;
1630         case XGI_DRAM_SIZE_4MB:
1631                 xgifb_info->video_size = 0x400000;
1632                 break;
1633         case XGI_DRAM_SIZE_8MB:
1634                 xgifb_info->video_size = 0x800000;
1635                 break;
1636         case XGI_DRAM_SIZE_16MB:
1637                 xgifb_info->video_size = 0x1000000;
1638                 break;
1639         case XGI_DRAM_SIZE_32MB:
1640                 xgifb_info->video_size = 0x2000000;
1641                 break;
1642         case XGI_DRAM_SIZE_64MB:
1643                 xgifb_info->video_size = 0x4000000;
1644                 break;
1645         case XGI_DRAM_SIZE_128MB:
1646                 xgifb_info->video_size = 0x8000000;
1647                 break;
1648         case XGI_DRAM_SIZE_256MB:
1649                 xgifb_info->video_size = 0x10000000;
1650                 break;
1651         default:
1652                 return -1;
1653         }
1654
1655         tmp = (reg & 0x0c) >> 2;
1656         switch (xgifb_info->chip) {
1657         case XG20:
1658         case XG21:
1659         case XG27:
1660                 ChannelNum = 1;
1661                 break;
1662
1663         case XG42:
1664                 if (reg & 0x04)
1665                         ChannelNum = 2;
1666                 else
1667                         ChannelNum = 1;
1668                 break;
1669
1670         case XG45:
1671                 if (tmp == 1)
1672                         ChannelNum = 2;
1673                 else if (tmp == 2)
1674                         ChannelNum = 3;
1675                 else if (tmp == 3)
1676                         ChannelNum = 4;
1677                 else
1678                         ChannelNum = 1;
1679                 break;
1680
1681         case XG40:
1682         default:
1683                 if (tmp == 2)
1684                         ChannelNum = 2;
1685                 else if (tmp == 3)
1686                         ChannelNum = 3;
1687                 else
1688                         ChannelNum = 1;
1689                 break;
1690         }
1691
1692         xgifb_info->video_size = xgifb_info->video_size * ChannelNum;
1693         /* PLiad fixed for benchmarking and fb set */
1694         /* xgifb_info->video_size = 0x200000; */ /* 1024x768x16 */
1695         /* xgifb_info->video_size = 0x1000000; */ /* benchmark */
1696
1697         pr_info("SR14=%x DramSzie %x ChannelNum %x\n",
1698                reg,
1699                xgifb_info->video_size, ChannelNum);
1700         return 0;
1701
1702 }
1703
1704 static void XGIfb_detect_VB(struct xgifb_video_info *xgifb_info)
1705 {
1706         u8 cr32, temp = 0;
1707
1708         xgifb_info->TV_plug = xgifb_info->TV_type = 0;
1709
1710         switch (xgifb_info->hasVB) {
1711         case HASVB_LVDS_CHRONTEL:
1712         case HASVB_CHRONTEL:
1713                 break;
1714         case HASVB_301:
1715         case HASVB_302:
1716                 /* XGI_Sense30x(); */ /* Yi-Lin TV Sense? */
1717                 break;
1718         }
1719
1720         cr32 = xgifb_reg_get(XGICR, IND_XGI_SCRATCH_REG_CR32);
1721
1722         if ((cr32 & SIS_CRT1) && !XGIfb_crt1off)
1723                 XGIfb_crt1off = 0;
1724         else {
1725                 if (cr32 & 0x5F)
1726                         XGIfb_crt1off = 1;
1727                 else
1728                         XGIfb_crt1off = 0;
1729         }
1730
1731         if (!xgifb_info->display2_force) {
1732                 if (cr32 & SIS_VB_TV)
1733                         xgifb_info->display2 = XGIFB_DISP_TV;
1734                 else if (cr32 & SIS_VB_LCD)
1735                         xgifb_info->display2 = XGIFB_DISP_LCD;
1736                 else if (cr32 & SIS_VB_CRT2)
1737                         xgifb_info->display2 = XGIFB_DISP_CRT;
1738                 else
1739                         xgifb_info->display2 = XGIFB_DISP_NONE;
1740         }
1741
1742         if (XGIfb_tvplug != -1)
1743                 /* PR/TW: Override with option */
1744                 xgifb_info->TV_plug = XGIfb_tvplug;
1745         else if (cr32 & SIS_VB_HIVISION) {
1746                 xgifb_info->TV_type = TVMODE_HIVISION;
1747                 xgifb_info->TV_plug = TVPLUG_SVIDEO;
1748         } else if (cr32 & SIS_VB_SVIDEO)
1749                 xgifb_info->TV_plug = TVPLUG_SVIDEO;
1750         else if (cr32 & SIS_VB_COMPOSITE)
1751                 xgifb_info->TV_plug = TVPLUG_COMPOSITE;
1752         else if (cr32 & SIS_VB_SCART)
1753                 xgifb_info->TV_plug = TVPLUG_SCART;
1754
1755         if (xgifb_info->TV_type == 0) {
1756                 temp = xgifb_reg_get(XGICR, 0x38);
1757                 if (temp & 0x10)
1758                         xgifb_info->TV_type = TVMODE_PAL;
1759                 else
1760                         xgifb_info->TV_type = TVMODE_NTSC;
1761         }
1762
1763         /* TW: Copy forceCRT1 option to CRT1off if option is given */
1764         if (XGIfb_forcecrt1 != -1) {
1765                 if (XGIfb_forcecrt1)
1766                         XGIfb_crt1off = 0;
1767                 else
1768                         XGIfb_crt1off = 1;
1769         }
1770 }
1771
1772 static int XGIfb_has_VB(struct xgifb_video_info *xgifb_info)
1773 {
1774         u8 vb_chipid;
1775
1776         vb_chipid = xgifb_reg_get(XGIPART4, 0x00);
1777         switch (vb_chipid) {
1778         case 0x01:
1779                 xgifb_info->hasVB = HASVB_301;
1780                 break;
1781         case 0x02:
1782                 xgifb_info->hasVB = HASVB_302;
1783                 break;
1784         default:
1785                 xgifb_info->hasVB = HASVB_NONE;
1786                 return 0;
1787         }
1788         return 1;
1789 }
1790
1791 static void XGIfb_get_VB_type(struct xgifb_video_info *xgifb_info)
1792 {
1793         u8 reg;
1794
1795         if (!XGIfb_has_VB(xgifb_info)) {
1796                 reg = xgifb_reg_get(XGICR, IND_XGI_SCRATCH_REG_CR37);
1797                 switch ((reg & SIS_EXTERNAL_CHIP_MASK) >> 1) {
1798                 case SIS_EXTERNAL_CHIP_LVDS:
1799                         xgifb_info->hasVB = HASVB_LVDS;
1800                         break;
1801                 case SIS_EXTERNAL_CHIP_LVDS_CHRONTEL:
1802                         xgifb_info->hasVB = HASVB_LVDS_CHRONTEL;
1803                         break;
1804                 default:
1805                         break;
1806                 }
1807         }
1808 }
1809
1810 static int __init xgifb_optval(char *fullopt, int validx)
1811 {
1812         unsigned long lres;
1813
1814         if (kstrtoul(fullopt + validx, 0, &lres) < 0 || lres > INT_MAX) {
1815                 pr_err("xgifb: invalid value for option: %s\n", fullopt);
1816                 return 0;
1817         }
1818         return lres;
1819 }
1820
1821 static int __init XGIfb_setup(char *options)
1822 {
1823         char *this_opt;
1824
1825         if (!options || !*options)
1826                 return 0;
1827
1828         pr_info("xgifb: options: %s\n", options);
1829
1830         while ((this_opt = strsep(&options, ",")) != NULL) {
1831
1832                 if (!*this_opt)
1833                         continue;
1834
1835                 if (!strncmp(this_opt, "mode:", 5)) {
1836                         mode = this_opt + 5;
1837                 } else if (!strncmp(this_opt, "vesa:", 5)) {
1838                         vesa = xgifb_optval(this_opt, 5);
1839                 } else if (!strncmp(this_opt, "vrate:", 6)) {
1840                         refresh_rate = xgifb_optval(this_opt, 6);
1841                 } else if (!strncmp(this_opt, "rate:", 5)) {
1842                         refresh_rate = xgifb_optval(this_opt, 5);
1843                 } else if (!strncmp(this_opt, "crt1off", 7)) {
1844                         XGIfb_crt1off = 1;
1845                 } else if (!strncmp(this_opt, "filter:", 7)) {
1846                         filter = xgifb_optval(this_opt, 7);
1847                 } else if (!strncmp(this_opt, "forcecrt2type:", 14)) {
1848                         XGIfb_search_crt2type(this_opt + 14);
1849                 } else if (!strncmp(this_opt, "forcecrt1:", 10)) {
1850                         XGIfb_forcecrt1 = xgifb_optval(this_opt, 10);
1851                 } else if (!strncmp(this_opt, "tvmode:", 7)) {
1852                         XGIfb_search_tvstd(this_opt + 7);
1853                 } else if (!strncmp(this_opt, "tvstandard:", 11)) {
1854                         XGIfb_search_tvstd(this_opt + 7);
1855                 } else if (!strncmp(this_opt, "dstn", 4)) {
1856                         enable_dstn = 1;
1857                         /* TW: DSTN overrules forcecrt2type */
1858                         XGIfb_crt2type = XGIFB_DISP_LCD;
1859                 } else if (!strncmp(this_opt, "noypan", 6)) {
1860                         XGIfb_ypan = 0;
1861                 } else {
1862                         mode = this_opt;
1863                 }
1864         }
1865         return 0;
1866 }
1867
1868 static int __devinit xgifb_probe(struct pci_dev *pdev,
1869                 const struct pci_device_id *ent)
1870 {
1871         u8 reg, reg1;
1872         u8 CR48, CR38;
1873         int ret;
1874         struct fb_info *fb_info;
1875         struct xgifb_video_info *xgifb_info;
1876         struct xgi_hw_device_info *hw_info;
1877
1878         fb_info = framebuffer_alloc(sizeof(*xgifb_info), &pdev->dev);
1879         if (!fb_info)
1880                 return -ENOMEM;
1881
1882         xgifb_info = fb_info->par;
1883         hw_info = &xgifb_info->hw_info;
1884         xgifb_info->fb_info = fb_info;
1885         xgifb_info->chip_id = pdev->device;
1886         pci_read_config_byte(pdev,
1887                              PCI_REVISION_ID,
1888                              &xgifb_info->revision_id);
1889         hw_info->jChipRevision = xgifb_info->revision_id;
1890
1891         xgifb_info->pcibus = pdev->bus->number;
1892         xgifb_info->pcislot = PCI_SLOT(pdev->devfn);
1893         xgifb_info->pcifunc = PCI_FUNC(pdev->devfn);
1894         xgifb_info->subsysvendor = pdev->subsystem_vendor;
1895         xgifb_info->subsysdevice = pdev->subsystem_device;
1896
1897         xgifb_info->video_base = pci_resource_start(pdev, 0);
1898         xgifb_info->mmio_base = pci_resource_start(pdev, 1);
1899         xgifb_info->mmio_size = pci_resource_len(pdev, 1);
1900         xgifb_info->vga_base = pci_resource_start(pdev, 2) + 0x30;
1901         pr_info("Relocate IO address: %Lx [%08lx]\n",
1902                (u64) pci_resource_start(pdev, 2),
1903                xgifb_info->vga_base);
1904
1905         if (pci_enable_device(pdev)) {
1906                 ret = -EIO;
1907                 goto error;
1908         }
1909
1910         if (XGIfb_crt2type != -1) {
1911                 xgifb_info->display2 = XGIfb_crt2type;
1912                 xgifb_info->display2_force = true;
1913         }
1914
1915         XGIRegInit(&xgifb_info->dev_info, xgifb_info->vga_base);
1916
1917         xgifb_reg_set(XGISR, IND_SIS_PASSWORD, SIS_PASSWORD);
1918         reg1 = xgifb_reg_get(XGISR, IND_SIS_PASSWORD);
1919
1920         if (reg1 != 0xa1) { /*I/O error */
1921                 pr_err("I/O error!!!");
1922                 ret = -EIO;
1923                 goto error;
1924         }
1925
1926         switch (xgifb_info->chip_id) {
1927         case PCI_DEVICE_ID_XGI_20:
1928                 xgifb_reg_or(XGICR, Index_CR_GPIO_Reg3, GPIOG_EN);
1929                 CR48 = xgifb_reg_get(XGICR, Index_CR_GPIO_Reg1);
1930                 if (CR48&GPIOG_READ)
1931                         xgifb_info->chip = XG21;
1932                 else
1933                         xgifb_info->chip = XG20;
1934                 break;
1935         case PCI_DEVICE_ID_XGI_40:
1936                 xgifb_info->chip = XG40;
1937                 break;
1938         case PCI_DEVICE_ID_XGI_41:
1939                 xgifb_info->chip = XG41;
1940                 break;
1941         case PCI_DEVICE_ID_XGI_42:
1942                 xgifb_info->chip = XG42;
1943                 break;
1944         case PCI_DEVICE_ID_XGI_27:
1945                 xgifb_info->chip = XG27;
1946                 break;
1947         default:
1948                 ret = -ENODEV;
1949                 goto error;
1950         }
1951
1952         pr_info("chipid = %x\n", xgifb_info->chip);
1953         hw_info->jChipType = xgifb_info->chip;
1954
1955         if (XGIfb_get_dram_size(xgifb_info)) {
1956                 pr_err("Fatal error: Unable to determine RAM size.\n");
1957                 ret = -ENODEV;
1958                 goto error;
1959         }
1960
1961         /* Enable PCI_LINEAR_ADDRESSING and MMIO_ENABLE  */
1962         xgifb_reg_or(XGISR,
1963                      IND_SIS_PCI_ADDRESS_SET,
1964                      (SIS_PCI_ADDR_ENABLE | SIS_MEM_MAP_IO_ENABLE));
1965         /* Enable 2D accelerator engine */
1966         xgifb_reg_or(XGISR, IND_SIS_MODULE_ENABLE, SIS_ENABLE_2D);
1967
1968         hw_info->ulVideoMemorySize = xgifb_info->video_size;
1969
1970         if (!request_mem_region(xgifb_info->video_base,
1971                                 xgifb_info->video_size,
1972                                 "XGIfb FB")) {
1973                 pr_err("unable request memory size %x\n",
1974                        xgifb_info->video_size);
1975                 pr_err("Fatal error: Unable to reserve frame buffer memory\n");
1976                 pr_err("Is there another framebuffer driver active?\n");
1977                 ret = -ENODEV;
1978                 goto error;
1979         }
1980
1981         if (!request_mem_region(xgifb_info->mmio_base,
1982                                 xgifb_info->mmio_size,
1983                                 "XGIfb MMIO")) {
1984                 pr_err("Fatal error: Unable to reserve MMIO region\n");
1985                 ret = -ENODEV;
1986                 goto error_0;
1987         }
1988
1989         xgifb_info->video_vbase = hw_info->pjVideoMemoryAddress =
1990         ioremap(xgifb_info->video_base, xgifb_info->video_size);
1991         xgifb_info->mmio_vbase = ioremap(xgifb_info->mmio_base,
1992                                             xgifb_info->mmio_size);
1993
1994         pr_info("Framebuffer at 0x%Lx, mapped to 0x%p, size %dk\n",
1995                (u64) xgifb_info->video_base,
1996                xgifb_info->video_vbase,
1997                xgifb_info->video_size / 1024);
1998
1999         pr_info("MMIO at 0x%Lx, mapped to 0x%p, size %ldk\n",
2000                (u64) xgifb_info->mmio_base, xgifb_info->mmio_vbase,
2001                xgifb_info->mmio_size / 1024);
2002
2003         pci_set_drvdata(pdev, xgifb_info);
2004         if (!XGIInitNew(pdev))
2005                 pr_err("XGIInitNew() failed!\n");
2006
2007         xgifb_info->mtrr = (unsigned int) 0;
2008
2009         xgifb_info->hasVB = HASVB_NONE;
2010         if ((xgifb_info->chip == XG20) ||
2011             (xgifb_info->chip == XG27)) {
2012                 xgifb_info->hasVB = HASVB_NONE;
2013         } else if (xgifb_info->chip == XG21) {
2014                 CR38 = xgifb_reg_get(XGICR, 0x38);
2015                 if ((CR38&0xE0) == 0xC0)
2016                         xgifb_info->display2 = XGIFB_DISP_LCD;
2017                 else if ((CR38&0xE0) == 0x60)
2018                         xgifb_info->hasVB = HASVB_CHRONTEL;
2019                 else
2020                         xgifb_info->hasVB = HASVB_NONE;
2021         } else {
2022                 XGIfb_get_VB_type(xgifb_info);
2023         }
2024
2025         hw_info->ujVBChipID = VB_CHIP_UNKNOWN;
2026
2027         hw_info->ulExternalChip = 0;
2028
2029         switch (xgifb_info->hasVB) {
2030         case HASVB_301:
2031                 reg = xgifb_reg_get(XGIPART4, 0x01);
2032                 if (reg >= 0xE0) {
2033                         hw_info->ujVBChipID = VB_CHIP_302LV;
2034                         pr_info("XGI302LV bridge detected (revision 0x%02x)\n", reg);
2035                 } else if (reg >= 0xD0) {
2036                         hw_info->ujVBChipID = VB_CHIP_301LV;
2037                         pr_info("XGI301LV bridge detected (revision 0x%02x)\n", reg);
2038                 }
2039                 /* else if (reg >= 0xB0) {
2040                         hw_info->ujVBChipID = VB_CHIP_301B;
2041                         reg1 = xgifb_reg_get(XGIPART4, 0x23);
2042                         printk("XGIfb: XGI301B bridge detected\n");
2043                 } */
2044                 else {
2045                         hw_info->ujVBChipID = VB_CHIP_301;
2046                         pr_info("XGI301 bridge detected\n");
2047                 }
2048                 break;
2049         case HASVB_302:
2050                 reg = xgifb_reg_get(XGIPART4, 0x01);
2051                 if (reg >= 0xE0) {
2052                         hw_info->ujVBChipID = VB_CHIP_302LV;
2053                         pr_info("XGI302LV bridge detected (revision 0x%02x)\n", reg);
2054                 } else if (reg >= 0xD0) {
2055                         hw_info->ujVBChipID = VB_CHIP_301LV;
2056                         pr_info("XGI302LV bridge detected (revision 0x%02x)\n", reg);
2057                 } else if (reg >= 0xB0) {
2058                         reg1 = xgifb_reg_get(XGIPART4, 0x23);
2059
2060                         hw_info->ujVBChipID = VB_CHIP_302B;
2061
2062                 } else {
2063                         hw_info->ujVBChipID = VB_CHIP_302;
2064                         pr_info("XGI302 bridge detected\n");
2065                 }
2066                 break;
2067         case HASVB_LVDS:
2068                 hw_info->ulExternalChip = 0x1;
2069                 pr_info("LVDS transmitter detected\n");
2070                 break;
2071         case HASVB_TRUMPION:
2072                 hw_info->ulExternalChip = 0x2;
2073                 pr_info("Trumpion Zurac LVDS scaler detected\n");
2074                 break;
2075         case HASVB_CHRONTEL:
2076                 hw_info->ulExternalChip = 0x4;
2077                 pr_info("Chrontel TV encoder detected\n");
2078                 break;
2079         case HASVB_LVDS_CHRONTEL:
2080                 hw_info->ulExternalChip = 0x5;
2081                 pr_info("LVDS transmitter and Chrontel TV encoder detected\n");
2082                 break;
2083         default:
2084                 pr_info("No or unknown bridge type detected\n");
2085                 break;
2086         }
2087
2088         if (xgifb_info->hasVB != HASVB_NONE)
2089                 XGIfb_detect_VB(xgifb_info);
2090         else if (xgifb_info->chip != XG21)
2091                 xgifb_info->display2 = XGIFB_DISP_NONE;
2092
2093         if (xgifb_info->display2 == XGIFB_DISP_LCD) {
2094                 if (!enable_dstn) {
2095                         reg = xgifb_reg_get(XGICR, IND_XGI_LCD_PANEL);
2096                         reg &= 0x0f;
2097                         hw_info->ulCRT2LCDType = XGI310paneltype[reg];
2098                 }
2099         }
2100
2101         if ((hw_info->ujVBChipID == VB_CHIP_302B) ||
2102                         (hw_info->ujVBChipID == VB_CHIP_301LV) ||
2103                         (hw_info->ujVBChipID == VB_CHIP_302LV)) {
2104                 int tmp;
2105                 tmp = xgifb_reg_get(XGICR, 0x34);
2106                 if (tmp <= 0x13) {
2107                         /* Currently on LCDA?
2108                          *(Some BIOSes leave CR38) */
2109                         tmp = xgifb_reg_get(XGICR, 0x38);
2110                         if ((tmp & 0x03) == 0x03) {
2111                                 /* XGI_Pr.XGI_UseLCDA = 1; */
2112                         } else {
2113                                 /* Currently on LCDA?
2114                                  *(Some newer BIOSes set D0 in CR35) */
2115                                 tmp = xgifb_reg_get(XGICR, 0x35);
2116                                 if (tmp & 0x01) {
2117                                         /* XGI_Pr.XGI_UseLCDA = 1; */
2118                                 } else {
2119                                         tmp = xgifb_reg_get(XGICR,
2120                                                             0x30);
2121                                         if (tmp & 0x20) {
2122                                                 tmp = xgifb_reg_get(
2123                                                         XGIPART1, 0x13);
2124                                         }
2125                                 }
2126                         }
2127                 }
2128
2129         }
2130
2131         xgifb_info->mode_idx = -1;
2132
2133         if (mode)
2134                 XGIfb_search_mode(xgifb_info, mode);
2135         else if (vesa != -1)
2136                 XGIfb_search_vesamode(xgifb_info, vesa);
2137
2138         if (xgifb_info->mode_idx >= 0)
2139                 xgifb_info->mode_idx =
2140                         XGIfb_validate_mode(xgifb_info, xgifb_info->mode_idx);
2141
2142         if (xgifb_info->mode_idx < 0) {
2143                 if (xgifb_info->display2 == XGIFB_DISP_LCD &&
2144                     xgifb_info->chip == XG21)
2145                         xgifb_info->mode_idx =
2146                                 XGIfb_GetXG21DefaultLVDSModeIdx(xgifb_info);
2147                 else
2148                         xgifb_info->mode_idx = DEFAULT_MODE;
2149         }
2150
2151         if (xgifb_info->mode_idx < 0) {
2152                 dev_err(&pdev->dev, "no supported video mode found\n");
2153                 goto error_1;
2154         }
2155
2156         /* yilin set default refresh rate */
2157         xgifb_info->refresh_rate = refresh_rate;
2158         if (xgifb_info->refresh_rate == 0)
2159                 xgifb_info->refresh_rate = 60;
2160         if (XGIfb_search_refresh_rate(xgifb_info,
2161                         xgifb_info->refresh_rate) == 0) {
2162                 xgifb_info->rate_idx =
2163                         XGIbios_mode[xgifb_info->mode_idx].rate_idx;
2164                 xgifb_info->refresh_rate = 60;
2165         }
2166
2167         xgifb_info->video_bpp = XGIbios_mode[xgifb_info->mode_idx].bpp;
2168         xgifb_info->video_vwidth =
2169                 xgifb_info->video_width =
2170                         XGIbios_mode[xgifb_info->mode_idx].xres;
2171         xgifb_info->video_vheight =
2172                 xgifb_info->video_height =
2173                         XGIbios_mode[xgifb_info->mode_idx].yres;
2174         xgifb_info->org_x = xgifb_info->org_y = 0;
2175         xgifb_info->video_linelength =
2176                 xgifb_info->video_width *
2177                 (xgifb_info->video_bpp >> 3);
2178         switch (xgifb_info->video_bpp) {
2179         case 8:
2180                 xgifb_info->DstColor = 0x0000;
2181                 xgifb_info->XGI310_AccelDepth = 0x00000000;
2182                 xgifb_info->video_cmap_len = 256;
2183                 break;
2184         case 16:
2185                 xgifb_info->DstColor = 0x8000;
2186                 xgifb_info->XGI310_AccelDepth = 0x00010000;
2187                 xgifb_info->video_cmap_len = 16;
2188                 break;
2189         case 32:
2190                 xgifb_info->DstColor = 0xC000;
2191                 xgifb_info->XGI310_AccelDepth = 0x00020000;
2192                 xgifb_info->video_cmap_len = 16;
2193                 break;
2194         default:
2195                 xgifb_info->video_cmap_len = 16;
2196                 pr_info("Unsupported depth %d\n",
2197                        xgifb_info->video_bpp);
2198                 break;
2199         }
2200
2201         pr_info("Default mode is %dx%dx%d (%dHz)\n",
2202                xgifb_info->video_width,
2203                xgifb_info->video_height,
2204                xgifb_info->video_bpp,
2205                xgifb_info->refresh_rate);
2206
2207         fb_info->var.red.length         = 8;
2208         fb_info->var.green.length       = 8;
2209         fb_info->var.blue.length        = 8;
2210         fb_info->var.activate           = FB_ACTIVATE_NOW;
2211         fb_info->var.height             = -1;
2212         fb_info->var.width              = -1;
2213         fb_info->var.vmode              = FB_VMODE_NONINTERLACED;
2214         fb_info->var.xres               = xgifb_info->video_width;
2215         fb_info->var.xres_virtual       = xgifb_info->video_width;
2216         fb_info->var.yres               = xgifb_info->video_height;
2217         fb_info->var.yres_virtual       = xgifb_info->video_height;
2218         fb_info->var.bits_per_pixel     = xgifb_info->video_bpp;
2219
2220         XGIfb_bpp_to_var(xgifb_info, &fb_info->var);
2221
2222         fb_info->var.pixclock = (u32) (1000000000 /
2223                         XGIfb_mode_rate_to_dclock(&xgifb_info->dev_info,
2224                                 hw_info,
2225                                 XGIbios_mode[xgifb_info->mode_idx].mode_no,
2226                                 xgifb_info->rate_idx));
2227
2228         if (XGIfb_mode_rate_to_ddata(&xgifb_info->dev_info, hw_info,
2229                 XGIbios_mode[xgifb_info->mode_idx].mode_no,
2230                 xgifb_info->rate_idx,
2231                 &fb_info->var.left_margin,
2232                 &fb_info->var.right_margin,
2233                 &fb_info->var.upper_margin,
2234                 &fb_info->var.lower_margin,
2235                 &fb_info->var.hsync_len,
2236                 &fb_info->var.vsync_len,
2237                 &fb_info->var.sync,
2238                 &fb_info->var.vmode)) {
2239
2240                 if ((fb_info->var.vmode & FB_VMODE_MASK) ==
2241                     FB_VMODE_INTERLACED) {
2242                         fb_info->var.yres <<= 1;
2243                         fb_info->var.yres_virtual <<= 1;
2244                 } else if ((fb_info->var.vmode & FB_VMODE_MASK) ==
2245                            FB_VMODE_DOUBLE) {
2246                         fb_info->var.pixclock >>= 1;
2247                         fb_info->var.yres >>= 1;
2248                         fb_info->var.yres_virtual >>= 1;
2249                 }
2250
2251         }
2252
2253         strncpy(fb_info->fix.id, "XGI", sizeof(fb_info->fix.id) - 1);
2254         fb_info->fix.type       = FB_TYPE_PACKED_PIXELS;
2255         fb_info->fix.xpanstep   = 1;
2256         fb_info->fix.ypanstep   = 1;
2257
2258         fb_info->flags = FBINFO_FLAG_DEFAULT;
2259         fb_info->screen_base = xgifb_info->video_vbase;
2260         fb_info->fbops = &XGIfb_ops;
2261         XGIfb_get_fix(&fb_info->fix, -1, fb_info);
2262         fb_info->pseudo_palette = xgifb_info->pseudo_palette;
2263
2264         fb_alloc_cmap(&fb_info->cmap, 256 , 0);
2265
2266 #ifdef CONFIG_MTRR
2267         xgifb_info->mtrr = mtrr_add(xgifb_info->video_base,
2268                 xgifb_info->video_size, MTRR_TYPE_WRCOMB, 1);
2269         if (xgifb_info->mtrr >= 0)
2270                 dev_info(&pdev->dev, "added MTRR\n");
2271 #endif
2272
2273         if (register_framebuffer(fb_info) < 0) {
2274                 ret = -EINVAL;
2275                 goto error_mtrr;
2276         }
2277
2278         dumpVGAReg();
2279
2280         return 0;
2281
2282 error_mtrr:
2283 #ifdef CONFIG_MTRR
2284         if (xgifb_info->mtrr >= 0)
2285                 mtrr_del(xgifb_info->mtrr, xgifb_info->video_base,
2286                         xgifb_info->video_size);
2287 #endif /* CONFIG_MTRR */
2288 error_1:
2289         iounmap(xgifb_info->mmio_vbase);
2290         iounmap(xgifb_info->video_vbase);
2291         release_mem_region(xgifb_info->mmio_base, xgifb_info->mmio_size);
2292 error_0:
2293         release_mem_region(xgifb_info->video_base, xgifb_info->video_size);
2294 error:
2295         framebuffer_release(fb_info);
2296         return ret;
2297 }
2298
2299 /*****************************************************/
2300 /*                PCI DEVICE HANDLING                */
2301 /*****************************************************/
2302
2303 static void __devexit xgifb_remove(struct pci_dev *pdev)
2304 {
2305         struct xgifb_video_info *xgifb_info = pci_get_drvdata(pdev);
2306         struct fb_info *fb_info = xgifb_info->fb_info;
2307
2308         unregister_framebuffer(fb_info);
2309 #ifdef CONFIG_MTRR
2310         if (xgifb_info->mtrr >= 0)
2311                 mtrr_del(xgifb_info->mtrr, xgifb_info->video_base,
2312                         xgifb_info->video_size);
2313 #endif /* CONFIG_MTRR */
2314         iounmap(xgifb_info->mmio_vbase);
2315         iounmap(xgifb_info->video_vbase);
2316         release_mem_region(xgifb_info->mmio_base, xgifb_info->mmio_size);
2317         release_mem_region(xgifb_info->video_base, xgifb_info->video_size);
2318         framebuffer_release(fb_info);
2319         pci_set_drvdata(pdev, NULL);
2320 }
2321
2322 static struct pci_driver xgifb_driver = {
2323         .name = "xgifb",
2324         .id_table = xgifb_pci_table,
2325         .probe = xgifb_probe,
2326         .remove = __devexit_p(xgifb_remove)
2327 };
2328
2329 static int __init xgifb_init(void)
2330 {
2331         char *option = NULL;
2332
2333         if (forcecrt2type != NULL)
2334                 XGIfb_search_crt2type(forcecrt2type);
2335         if (fb_get_options("xgifb", &option))
2336                 return -ENODEV;
2337         XGIfb_setup(option);
2338
2339         return pci_register_driver(&xgifb_driver);
2340 }
2341
2342 module_init(xgifb_init);
2343
2344 /*****************************************************/
2345 /*                      MODULE                       */
2346 /*****************************************************/
2347
2348 #ifdef MODULE
2349
2350 MODULE_DESCRIPTION("Z7 Z9 Z9S Z11 framebuffer device driver");
2351 MODULE_LICENSE("GPL");
2352 MODULE_AUTHOR("XGITECH , Others");
2353
2354 module_param(mode, charp, 0);
2355 module_param(vesa, int, 0);
2356 module_param(filter, int, 0);
2357 module_param(forcecrt2type, charp, 0);
2358
2359 MODULE_PARM_DESC(forcecrt2type,
2360         "\nForce the second display output type. Possible values are NONE,\n"
2361         "LCD, TV, VGA, SVIDEO or COMPOSITE.\n");
2362
2363 MODULE_PARM_DESC(mode,
2364         "\nSelects the desired default display mode in the format XxYxDepth,\n"
2365         "eg. 1024x768x16.\n");
2366
2367 MODULE_PARM_DESC(vesa,
2368         "\nSelects the desired default display mode by VESA mode number, eg.\n"
2369         "0x117.\n");
2370
2371 MODULE_PARM_DESC(filter,
2372                 "\nSelects TV flicker filter type (only for systems with a SiS301 video bridge).\n"
2373                 "(Possible values 0-7, default: [no filter])\n");
2374
2375 static void __exit xgifb_remove_module(void)
2376 {
2377         pci_unregister_driver(&xgifb_driver);
2378         pr_debug("Module unloaded\n");
2379 }
2380
2381 module_exit(xgifb_remove_module);
2382
2383 #endif  /*  /MODULE  */