drivers/video/nvidia/nvidia.c

   1 /*
   2  * linux/drivers/video/nvidia/nvidia.c - nVidia fb driver
   3  *
   4  * Copyright 2004 Antonino Daplas <adaplas@pol.net>
   5  *
   6  * This file is subject to the terms and conditions of the GNU General Public
   7  * License.  See the file COPYING in the main directory of this archive
   8  * for more details.
   9  *
  10  */
  11
  12 #include <linux/module.h>
  13 #include <linux/kernel.h>
  14 #include <linux/errno.h>
  15 #include <linux/string.h>
  16 #include <linux/mm.h>
  17 #include <linux/slab.h>
  18 #include <linux/delay.h>
  19 #include <linux/fb.h>
  20 #include <linux/init.h>
  21 #include <linux/pci.h>
  22 #include <linux/console.h>
  23 #include <linux/backlight.h>
  24 #ifdef CONFIG_MTRR
  25 #include <asm/mtrr.h>
  26 #endif
  27 #ifdef CONFIG_PPC_OF
  28 #include <asm/prom.h>
  29 #include <asm/pci-bridge.h>
  30 #endif
  31
  32 #include "nv_local.h"
  33 #include "nv_type.h"
  34 #include "nv_proto.h"
  35 #include "nv_dma.h"
  36
  37 #ifndef CONFIG_PCI              /* sanity check */
  38 #error This driver requires PCI support.
  39 #endif
  40
  41 #undef CONFIG_FB_NVIDIA_DEBUG
  42 #ifdef CONFIG_FB_NVIDIA_DEBUG
  43 #define NVTRACE          printk
  44 #else
  45 #define NVTRACE          if (0) printk
  46 #endif
  47
  48 #define NVTRACE_ENTER(...)  NVTRACE("%s START\n", __FUNCTION__)
  49 #define NVTRACE_LEAVE(...)  NVTRACE("%s END\n", __FUNCTION__)
  50
  51 #ifdef CONFIG_FB_NVIDIA_DEBUG
  52 #define assert(expr) \
  53         if (!(expr)) { \
  54         printk( "Assertion failed! %s,%s,%s,line=%d\n",\
  55         #expr,__FILE__,__FUNCTION__,__LINE__); \
  56         BUG(); \
  57         }
  58 #else
  59 #define assert(expr)
  60 #endif
  61
  62 #define PFX "nvidiafb: "
  63
  64 /* HW cursor parameters */
  65 #define MAX_CURS                32
  66
  67 static struct pci_device_id nvidiafb_pci_tbl[] = {
  68         {PCI_VENDOR_ID_NVIDIA, PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID,
  69          PCI_BASE_CLASS_DISPLAY << 16, 0xff0000, 0},
  70         { 0, }
  71 };
  72 MODULE_DEVICE_TABLE(pci, nvidiafb_pci_tbl);
  73
  74 /* command line data, set in nvidiafb_setup() */
  75 static int flatpanel __devinitdata = -1;        /* Autodetect later */
  76 static int fpdither __devinitdata = -1;
  77 static int forceCRTC __devinitdata = -1;
  78 static int hwcur __devinitdata = 0;
  79 static int noaccel __devinitdata = 0;
  80 static int noscale __devinitdata = 0;
  81 static int paneltweak __devinitdata = 0;
  82 static int vram __devinitdata = 0;
  83 static int bpp __devinitdata = 8;
  84 #ifdef CONFIG_MTRR
  85 static int nomtrr __devinitdata = 0;
  86 #endif
  87
  88 static char *mode_option __devinitdata = NULL;
  89
  90 static struct fb_fix_screeninfo __devinitdata nvidiafb_fix = {
  91         .type = FB_TYPE_PACKED_PIXELS,
  92         .xpanstep = 8,
  93         .ypanstep = 1,
  94 };
  95
  96 static struct fb_var_screeninfo __devinitdata nvidiafb_default_var = {
  97         .xres = 640,
  98         .yres = 480,
  99         .xres_virtual = 640,
 100         .yres_virtual = 480,
 101         .bits_per_pixel = 8,
 102         .red = {0, 8, 0},
 103         .green = {0, 8, 0},
 104         .blue = {0, 8, 0},
 105         .transp = {0, 0, 0},
 106         .activate = FB_ACTIVATE_NOW,
 107         .height = -1,
 108         .width = -1,
 109         .pixclock = 39721,
 110         .left_margin = 40,
 111         .right_margin = 24,
 112         .upper_margin = 32,
 113         .lower_margin = 11,
 114         .hsync_len = 96,
 115         .vsync_len = 2,
 116         .vmode = FB_VMODE_NONINTERLACED
 117 };
 118
 119 static void nvidiafb_load_cursor_image(struct nvidia_par *par, u8 * data8,
 120                                        u16 bg, u16 fg, u32 w, u32 h)
 121 {
 122         u32 *data = (u32 *) data8;
 123         int i, j, k = 0;
 124         u32 b, tmp;
 125
 126         w = (w + 1) & ~1;
 127
 128         for (i = 0; i < h; i++) {
 129                 b = *data++;
 130                 reverse_order(&b);
 131
 132                 for (j = 0; j < w / 2; j++) {
 133                         tmp = 0;
 134 #if defined (__BIG_ENDIAN)
 135                         tmp = (b & (1 << 31)) ? fg << 16 : bg << 16;
 136                         b <<= 1;
 137                         tmp |= (b & (1 << 31)) ? fg : bg;
 138                         b <<= 1;
 139 #else
 140                         tmp = (b & 1) ? fg : bg;
 141                         b >>= 1;
 142                         tmp |= (b & 1) ? fg << 16 : bg << 16;
 143                         b >>= 1;
 144 #endif
 145                         NV_WR32(&par->CURSOR[k++], 0, tmp);
 146                 }
 147                 k += (MAX_CURS - w) / 2;
 148         }
 149 }
 150
 151 static void nvidia_write_clut(struct nvidia_par *par,
 152                               u8 regnum, u8 red, u8 green, u8 blue)
 153 {
 154         NVWriteDacMask(par, 0xff);
 155         NVWriteDacWriteAddr(par, regnum);
 156         NVWriteDacData(par, red);
 157         NVWriteDacData(par, green);
 158         NVWriteDacData(par, blue);
 159 }
 160
 161 static void nvidia_read_clut(struct nvidia_par *par,
 162                              u8 regnum, u8 * red, u8 * green, u8 * blue)
 163 {
 164         NVWriteDacMask(par, 0xff);
 165         NVWriteDacReadAddr(par, regnum);
 166         *red = NVReadDacData(par);
 167         *green = NVReadDacData(par);
 168         *blue = NVReadDacData(par);
 169 }
 170
 171 static int nvidia_panel_tweak(struct nvidia_par *par,
 172                               struct _riva_hw_state *state)
 173 {
 174         int tweak = 0;
 175
 176    if (par->paneltweak) {
 177            tweak = par->paneltweak;
 178    } else {
 179            /* begin flat panel hacks */
 180            /* This is unfortunate, but some chips need this register
 181               tweaked or else you get artifacts where adjacent pixels are
 182               swapped.  There are no hard rules for what to set here so all
 183               we can do is experiment and apply hacks. */
 184
 185            if(((par->Chipset & 0xffff) == 0x0328) && (state->bpp == 32)) {
 186                    /* At least one NV34 laptop needs this workaround. */
 187                    tweak = -1;
 188            }
 189
 190            if((par->Chipset & 0xfff0) == 0x0310) {
 191                    tweak = 1;
 192            }
 193            /* end flat panel hacks */
 194    }
 195
 196    return tweak;
 197 }
 198
 199 static void nvidia_vga_protect(struct nvidia_par *par, int on)
 200 {
 201         unsigned char tmp;
 202
 203         if (on) {
 204                 /*
 205                  * Turn off screen and disable sequencer.
 206                  */
 207                 tmp = NVReadSeq(par, 0x01);
 208
 209                 NVWriteSeq(par, 0x00, 0x01);            /* Synchronous Reset */
 210                 NVWriteSeq(par, 0x01, tmp | 0x20);      /* disable the display */
 211         } else {
 212                 /*
 213                  * Reenable sequencer, then turn on screen.
 214                  */
 215
 216                 tmp = NVReadSeq(par, 0x01);
 217
 218                 NVWriteSeq(par, 0x01, tmp & ~0x20);     /* reenable display */
 219                 NVWriteSeq(par, 0x00, 0x03);            /* End Reset */
 220         }
 221 }
 222
 223 static void nvidia_save_vga(struct nvidia_par *par,
 224                             struct _riva_hw_state *state)
 225 {
 226         int i;
 227
 228         NVTRACE_ENTER();
 229         NVLockUnlock(par, 0);
 230
 231         NVUnloadStateExt(par, state);
 232
 233         state->misc_output = NVReadMiscOut(par);
 234
 235         for (i = 0; i < NUM_CRT_REGS; i++)
 236                 state->crtc[i] = NVReadCrtc(par, i);
 237
 238         for (i = 0; i < NUM_ATC_REGS; i++)
 239                 state->attr[i] = NVReadAttr(par, i);
 240
 241         for (i = 0; i < NUM_GRC_REGS; i++)
 242                 state->gra[i] = NVReadGr(par, i);
 243
 244         for (i = 0; i < NUM_SEQ_REGS; i++)
 245                 state->seq[i] = NVReadSeq(par, i);
 246         NVTRACE_LEAVE();
 247 }
 248
 249 #undef DUMP_REG
 250
 251 static void nvidia_write_regs(struct nvidia_par *par,
 252                               struct _riva_hw_state *state)
 253 {
 254         int i;
 255
 256         NVTRACE_ENTER();
 257
 258         NVLoadStateExt(par, state);
 259
 260         NVWriteMiscOut(par, state->misc_output);
 261
 262         for (i = 1; i < NUM_SEQ_REGS; i++) {
 263 #ifdef DUMP_REG
 264                 printk(" SEQ[%02x] = %08x\n", i, state->seq[i]);
 265 #endif
 266                 NVWriteSeq(par, i, state->seq[i]);
 267         }
 268
 269         /* Ensure CRTC registers 0-7 are unlocked by clearing bit 7 of CRTC[17] */
 270         NVWriteCrtc(par, 0x11, state->crtc[0x11] & ~0x80);
 271
 272         for (i = 0; i < NUM_CRT_REGS; i++) {
 273                 switch (i) {
 274                 case 0x19:
 275                 case 0x20 ... 0x40:
 276                         break;
 277                 default:
 278 #ifdef DUMP_REG
 279                         printk("CRTC[%02x] = %08x\n", i, state->crtc[i]);
 280 #endif
 281                         NVWriteCrtc(par, i, state->crtc[i]);
 282                 }
 283         }
 284
 285         for (i = 0; i < NUM_GRC_REGS; i++) {
 286 #ifdef DUMP_REG
 287                 printk(" GRA[%02x] = %08x\n", i, state->gra[i]);
 288 #endif
 289                 NVWriteGr(par, i, state->gra[i]);
 290         }
 291
 292         for (i = 0; i < NUM_ATC_REGS; i++) {
 293 #ifdef DUMP_REG
 294                 printk("ATTR[%02x] = %08x\n", i, state->attr[i]);
 295 #endif
 296                 NVWriteAttr(par, i, state->attr[i]);
 297         }
 298
 299         NVTRACE_LEAVE();
 300 }
 301
 302 static int nvidia_calc_regs(struct fb_info *info)
 303 {
 304         struct nvidia_par *par = info->par;
 305         struct _riva_hw_state *state = &par->ModeReg;
 306         int i, depth = fb_get_color_depth(&info->var, &info->fix);
 307         int h_display = info->var.xres / 8 - 1;
 308         int h_start = (info->var.xres + info->var.right_margin) / 8 - 1;
 309         int h_end = (info->var.xres + info->var.right_margin +
 310                      info->var.hsync_len) / 8 - 1;
 311         int h_total = (info->var.xres + info->var.right_margin +
 312                        info->var.hsync_len + info->var.left_margin) / 8 - 5;
 313         int h_blank_s = h_display;
 314         int h_blank_e = h_total + 4;
 315         int v_display = info->var.yres - 1;
 316         int v_start = info->var.yres + info->var.lower_margin - 1;
 317         int v_end = (info->var.yres + info->var.lower_margin +
 318                      info->var.vsync_len) - 1;
 319         int v_total = (info->var.yres + info->var.lower_margin +
 320                        info->var.vsync_len + info->var.upper_margin) - 2;
 321         int v_blank_s = v_display;
 322         int v_blank_e = v_total + 1;
 323
 324         /*
 325          * Set all CRTC values.
 326          */
 327
 328         if (info->var.vmode & FB_VMODE_INTERLACED)
 329                 v_total |= 1;
 330
 331         if (par->FlatPanel == 1) {
 332                 v_start = v_total - 3;
 333                 v_end = v_total - 2;
 334                 v_blank_s = v_start;
 335                 h_start = h_total - 5;
 336                 h_end = h_total - 2;
 337                 h_blank_e = h_total + 4;
 338         }
 339
 340         state->crtc[0x0] = Set8Bits(h_total);
 341         state->crtc[0x1] = Set8Bits(h_display);
 342         state->crtc[0x2] = Set8Bits(h_blank_s);
 343         state->crtc[0x3] = SetBitField(h_blank_e, 4: 0, 4:0)
 344                 | SetBit(7);
 345         state->crtc[0x4] = Set8Bits(h_start);
 346         state->crtc[0x5] = SetBitField(h_blank_e, 5: 5, 7:7)
 347                 | SetBitField(h_end, 4: 0, 4:0);
 348         state->crtc[0x6] = SetBitField(v_total, 7: 0, 7:0);
 349         state->crtc[0x7] = SetBitField(v_total, 8: 8, 0:0)
 350                 | SetBitField(v_display, 8: 8, 1:1)
 351                 | SetBitField(v_start, 8: 8, 2:2)
 352                 | SetBitField(v_blank_s, 8: 8, 3:3)
 353                 | SetBit(4)
 354                 | SetBitField(v_total, 9: 9, 5:5)
 355                 | SetBitField(v_display, 9: 9, 6:6)
 356                 | SetBitField(v_start, 9: 9, 7:7);
 357         state->crtc[0x9] = SetBitField(v_blank_s, 9: 9, 5:5)
 358                 | SetBit(6)
 359                 | ((info->var.vmode & FB_VMODE_DOUBLE) ? 0x80 : 0x00);
 360         state->crtc[0x10] = Set8Bits(v_start);
 361         state->crtc[0x11] = SetBitField(v_end, 3: 0, 3:0) | SetBit(5);
 362         state->crtc[0x12] = Set8Bits(v_display);
 363         state->crtc[0x13] = ((info->var.xres_virtual / 8) *
 364                              (info->var.bits_per_pixel / 8));
 365         state->crtc[0x15] = Set8Bits(v_blank_s);
 366         state->crtc[0x16] = Set8Bits(v_blank_e);
 367
 368         state->attr[0x10] = 0x01;
 369
 370         if (par->Television)
 371                 state->attr[0x11] = 0x00;
 372
 373         state->screen = SetBitField(h_blank_e, 6: 6, 4:4)
 374                 | SetBitField(v_blank_s, 10: 10, 3:3)
 375                 | SetBitField(v_start, 10: 10, 2:2)
 376                 | SetBitField(v_display, 10: 10, 1:1)
 377                 | SetBitField(v_total, 10: 10, 0:0);
 378
 379         state->horiz = SetBitField(h_total, 8: 8, 0:0)
 380                 | SetBitField(h_display, 8: 8, 1:1)
 381                 | SetBitField(h_blank_s, 8: 8, 2:2)
 382                 | SetBitField(h_start, 8: 8, 3:3);
 383
 384         state->extra = SetBitField(v_total, 11: 11, 0:0)
 385                 | SetBitField(v_display, 11: 11, 2:2)
 386                 | SetBitField(v_start, 11: 11, 4:4)
 387                 | SetBitField(v_blank_s, 11: 11, 6:6);
 388
 389         if (info->var.vmode & FB_VMODE_INTERLACED) {
 390                 h_total = (h_total >> 1) & ~1;
 391                 state->interlace = Set8Bits(h_total);
 392                 state->horiz |= SetBitField(h_total, 8: 8, 4:4);
 393         } else {
 394                 state->interlace = 0xff;        /* interlace off */
 395         }
 396
 397         /*
 398          * Calculate the extended registers.
 399          */
 400
 401         if (depth < 24)
 402                 i = depth;
 403         else
 404                 i = 32;
 405
 406         if (par->Architecture >= NV_ARCH_10)
 407                 par->CURSOR = (volatile u32 __iomem *)(info->screen_base +
 408                                                        par->CursorStart);
 409
 410         if (info->var.sync & FB_SYNC_HOR_HIGH_ACT)
 411                 state->misc_output &= ~0x40;
 412         else
 413                 state->misc_output |= 0x40;
 414         if (info->var.sync & FB_SYNC_VERT_HIGH_ACT)
 415                 state->misc_output &= ~0x80;
 416         else
 417                 state->misc_output |= 0x80;
 418
 419         NVCalcStateExt(par, state, i, info->var.xres_virtual,
 420                        info->var.xres, info->var.yres_virtual,
 421                        1000000000 / info->var.pixclock, info->var.vmode);
 422
 423         state->scale = NV_RD32(par->PRAMDAC, 0x00000848) & 0xfff000ff;
 424         if (par->FlatPanel == 1) {
 425                 state->pixel |= (1 << 7);
 426
 427                 if (!par->fpScaler || (par->fpWidth <= info->var.xres)
 428                     || (par->fpHeight <= info->var.yres)) {
 429                         state->scale |= (1 << 8);
 430                 }
 431
 432                 if (!par->crtcSync_read) {
 433                         state->crtcSync = NV_RD32(par->PRAMDAC, 0x0828);
 434                         par->crtcSync_read = 1;
 435                 }
 436
 437                 par->PanelTweak = nvidia_panel_tweak(par, state);
 438         }
 439
 440         state->vpll = state->pll;
 441         state->vpll2 = state->pll;
 442         state->vpllB = state->pllB;
 443         state->vpll2B = state->pllB;
 444
 445         VGA_WR08(par->PCIO, 0x03D4, 0x1C);
 446         state->fifo = VGA_RD08(par->PCIO, 0x03D5) & ~(1<<5);
 447
 448         if (par->CRTCnumber) {
 449                 state->head = NV_RD32(par->PCRTC0, 0x00000860) & ~0x00001000;
 450                 state->head2 = NV_RD32(par->PCRTC0, 0x00002860) | 0x00001000;
 451                 state->crtcOwner = 3;
 452                 state->pllsel |= 0x20000800;
 453                 state->vpll = NV_RD32(par->PRAMDAC0, 0x00000508);
 454                 if (par->twoStagePLL)
 455                         state->vpllB = NV_RD32(par->PRAMDAC0, 0x00000578);
 456         } else if (par->twoHeads) {
 457                 state->head = NV_RD32(par->PCRTC0, 0x00000860) | 0x00001000;
 458                 state->head2 = NV_RD32(par->PCRTC0, 0x00002860) & ~0x00001000;
 459                 state->crtcOwner = 0;
 460                 state->vpll2 = NV_RD32(par->PRAMDAC0, 0x0520);
 461                 if (par->twoStagePLL)
 462                         state->vpll2B = NV_RD32(par->PRAMDAC0, 0x057C);
 463         }
 464
 465         state->cursorConfig = 0x00000100;
 466
 467         if (info->var.vmode & FB_VMODE_DOUBLE)
 468                 state->cursorConfig |= (1 << 4);
 469
 470         if (par->alphaCursor) {
 471                 if ((par->Chipset & 0x0ff0) != 0x0110)
 472                         state->cursorConfig |= 0x04011000;
 473                 else
 474                         state->cursorConfig |= 0x14011000;
 475                 state->general |= (1 << 29);
 476         } else
 477                 state->cursorConfig |= 0x02000000;
 478
 479         if (par->twoHeads) {
 480                 if ((par->Chipset & 0x0ff0) == 0x0110) {
 481                         state->dither = NV_RD32(par->PRAMDAC, 0x0528) &
 482                             ~0x00010000;
 483                         if (par->FPDither)
 484                                 state->dither |= 0x00010000;
 485                 } else {
 486                         state->dither = NV_RD32(par->PRAMDAC, 0x083C) & ~1;
 487                         if (par->FPDither)
 488                                 state->dither |= 1;
 489                 }
 490         }
 491
 492         state->timingH = 0;
 493         state->timingV = 0;
 494         state->displayV = info->var.xres;
 495
 496         return 0;
 497 }
 498
 499 static void nvidia_init_vga(struct fb_info *info)
 500 {
 501         struct nvidia_par *par = info->par;
 502         struct _riva_hw_state *state = &par->ModeReg;
 503         int i;
 504
 505         for (i = 0; i < 0x10; i++)
 506                 state->attr[i] = i;
 507         state->attr[0x10] = 0x41;
 508         state->attr[0x11] = 0xff;
 509         state->attr[0x12] = 0x0f;
 510         state->attr[0x13] = 0x00;
 511         state->attr[0x14] = 0x00;
 512
 513         memset(state->crtc, 0x00, NUM_CRT_REGS);
 514         state->crtc[0x0a] = 0x20;
 515         state->crtc[0x17] = 0xe3;
 516         state->crtc[0x18] = 0xff;
 517         state->crtc[0x28] = 0x40;
 518
 519         memset(state->gra, 0x00, NUM_GRC_REGS);
 520         state->gra[0x05] = 0x40;
 521         state->gra[0x06] = 0x05;
 522         state->gra[0x07] = 0x0f;
 523         state->gra[0x08] = 0xff;
 524
 525         state->seq[0x00] = 0x03;
 526         state->seq[0x01] = 0x01;
 527         state->seq[0x02] = 0x0f;
 528         state->seq[0x03] = 0x00;
 529         state->seq[0x04] = 0x0e;
 530
 531         state->misc_output = 0xeb;
 532 }
 533
 534 static int nvidiafb_cursor(struct fb_info *info, struct fb_cursor *cursor)
 535 {
 536         struct nvidia_par *par = info->par;
 537         u8 data[MAX_CURS * MAX_CURS / 8];
 538         int i, set = cursor->set;
 539         u16 fg, bg;
 540
 541         if (cursor->image.width > MAX_CURS || cursor->image.height > MAX_CURS)
 542                 return -ENXIO;
 543
 544         NVShowHideCursor(par, 0);
 545
 546         if (par->cursor_reset) {
 547                 set = FB_CUR_SETALL;
 548                 par->cursor_reset = 0;
 549         }
 550
 551         if (set & FB_CUR_SETSIZE)
 552                 memset_io(par->CURSOR, 0, MAX_CURS * MAX_CURS * 2);
 553
 554         if (set & FB_CUR_SETPOS) {
 555                 u32 xx, yy, temp;
 556
 557                 yy = cursor->image.dy - info->var.yoffset;
 558                 xx = cursor->image.dx - info->var.xoffset;
 559                 temp = xx & 0xFFFF;
 560                 temp |= yy << 16;
 561
 562                 NV_WR32(par->PRAMDAC, 0x0000300, temp);
 563         }
 564
 565         if (set & (FB_CUR_SETSHAPE | FB_CUR_SETCMAP | FB_CUR_SETIMAGE)) {
 566                 u32 bg_idx = cursor->image.bg_color;
 567                 u32 fg_idx = cursor->image.fg_color;
 568                 u32 s_pitch = (cursor->image.width + 7) >> 3;
 569                 u32 d_pitch = MAX_CURS / 8;
 570                 u8 *dat = (u8 *) cursor->image.data;
 571                 u8 *msk = (u8 *) cursor->mask;
 572                 u8 *src;
 573
 574                 src = kmalloc(s_pitch * cursor->image.height, GFP_ATOMIC);
 575
 576                 if (src) {
 577                         switch (cursor->rop) {
 578                         case ROP_XOR:
 579                                 for (i = 0; i < s_pitch * cursor->image.height; i++)
 580                                         src[i] = dat[i] ^ msk[i];
 581                                 break;
 582                         case ROP_COPY:
 583                         default:
 584                                 for (i = 0; i < s_pitch * cursor->image.height; i++)
 585                                         src[i] = dat[i] & msk[i];
 586                                 break;
 587                         }
 588
 589                         fb_pad_aligned_buffer(data, d_pitch, src, s_pitch,
 590                                                 cursor->image.height);
 591
 592                         bg = ((info->cmap.red[bg_idx] & 0xf8) << 7) |
 593                             ((info->cmap.green[bg_idx] & 0xf8) << 2) |
 594                             ((info->cmap.blue[bg_idx] & 0xf8) >> 3) | 1 << 15;
 595
 596                         fg = ((info->cmap.red[fg_idx] & 0xf8) << 7) |
 597                             ((info->cmap.green[fg_idx] & 0xf8) << 2) |
 598                             ((info->cmap.blue[fg_idx] & 0xf8) >> 3) | 1 << 15;
 599
 600                         NVLockUnlock(par, 0);
 601
 602                         nvidiafb_load_cursor_image(par, data, bg, fg,
 603                                                    cursor->image.width,
 604                                                    cursor->image.height);
 605                         kfree(src);
 606                 }
 607         }
 608
 609         if (cursor->enable)
 610                 NVShowHideCursor(par, 1);
 611
 612         return 0;
 613 }
 614
 615 static int nvidiafb_set_par(struct fb_info *info)
 616 {
 617         struct nvidia_par *par = info->par;
 618
 619         NVTRACE_ENTER();
 620
 621         NVLockUnlock(par, 1);
 622         if (!par->FlatPanel || !par->twoHeads)
 623                 par->FPDither = 0;
 624
 625         if (par->FPDither < 0) {
 626                 if ((par->Chipset & 0x0ff0) == 0x0110)
 627                         par->FPDither = !!(NV_RD32(par->PRAMDAC, 0x0528)
 628                                            & 0x00010000);
 629                 else
 630                         par->FPDither = !!(NV_RD32(par->PRAMDAC, 0x083C) & 1);
 631                 printk(KERN_INFO PFX "Flat panel dithering %s\n",
 632                        par->FPDither ? "enabled" : "disabled");
 633         }
 634
 635         info->fix.visual = (info->var.bits_per_pixel == 8) ?
 636             FB_VISUAL_PSEUDOCOLOR : FB_VISUAL_DIRECTCOLOR;
 637
 638         nvidia_init_vga(info);
 639         nvidia_calc_regs(info);
 640
 641         NVLockUnlock(par, 0);
 642         if (par->twoHeads) {
 643                 VGA_WR08(par->PCIO, 0x03D4, 0x44);
 644                 VGA_WR08(par->PCIO, 0x03D5, par->ModeReg.crtcOwner);
 645                 NVLockUnlock(par, 0);
 646         }
 647
 648         nvidia_vga_protect(par, 1);
 649
 650         nvidia_write_regs(par, &par->ModeReg);
 651         NVSetStartAddress(par, 0);
 652
 653 #if defined (__BIG_ENDIAN)
 654         /* turn on LFB swapping */
 655         {
 656                 unsigned char tmp;
 657
 658                 VGA_WR08(par->PCIO, 0x3d4, 0x46);
 659                 tmp = VGA_RD08(par->PCIO, 0x3d5);
 660                 tmp |= (1 << 7);
 661                 VGA_WR08(par->PCIO, 0x3d5, tmp);
 662     }
 663 #endif
 664
 665         info->fix.line_length = (info->var.xres_virtual *
 666                                  info->var.bits_per_pixel) >> 3;
 667         if (info->var.accel_flags) {
 668                 info->fbops->fb_imageblit = nvidiafb_imageblit;
 669                 info->fbops->fb_fillrect = nvidiafb_fillrect;
 670                 info->fbops->fb_copyarea = nvidiafb_copyarea;
 671                 info->fbops->fb_sync = nvidiafb_sync;
 672                 info->pixmap.scan_align = 4;
 673                 info->flags &= ~FBINFO_HWACCEL_DISABLED;
 674                 NVResetGraphics(info);
 675         } else {
 676                 info->fbops->fb_imageblit = cfb_imageblit;
 677                 info->fbops->fb_fillrect = cfb_fillrect;
 678                 info->fbops->fb_copyarea = cfb_copyarea;
 679                 info->fbops->fb_sync = NULL;
 680                 info->pixmap.scan_align = 1;
 681                 info->flags |= FBINFO_HWACCEL_DISABLED;
 682         }
 683
 684         par->cursor_reset = 1;
 685
 686         nvidia_vga_protect(par, 0);
 687
 688         NVTRACE_LEAVE();
 689         return 0;
 690 }
 691
 692 static int nvidiafb_setcolreg(unsigned regno, unsigned red, unsigned green,
 693                               unsigned blue, unsigned transp,
 694                               struct fb_info *info)
 695 {
 696         struct nvidia_par *par = info->par;
 697         int i;
 698
 699         NVTRACE_ENTER();
 700         if (regno >= (1 << info->var.green.length))
 701                 return -EINVAL;
 702
 703         if (info->var.grayscale) {
 704                 /* gray = 0.30*R + 0.59*G + 0.11*B */
 705                 red = green = blue = (red * 77 + green * 151 + blue * 28) >> 8;
 706         }
 707
 708         if (regno < 16 && info->fix.visual == FB_VISUAL_DIRECTCOLOR) {
 709                 ((u32 *) info->pseudo_palette)[regno] =
 710                     (regno << info->var.red.offset) |
 711                     (regno << info->var.green.offset) |
 712                     (regno << info->var.blue.offset);
 713         }
 714
 715         switch (info->var.bits_per_pixel) {
 716         case 8:
 717                 /* "transparent" stuff is completely ignored. */
 718                 nvidia_write_clut(par, regno, red >> 8, green >> 8, blue >> 8);
 719                 break;
 720         case 16:
 721                 if (info->var.green.length == 5) {
 722                         for (i = 0; i < 8; i++) {
 723                                 nvidia_write_clut(par, regno * 8 + i, red >> 8,
 724                                                   green >> 8, blue >> 8);
 725                         }
 726                 } else {
 727                         u8 r, g, b;
 728
 729                         if (regno < 32) {
 730                                 for (i = 0; i < 8; i++) {
 731                                         nvidia_write_clut(par, regno * 8 + i,
 732                                                           red >> 8, green >> 8,
 733                                                           blue >> 8);
 734                                 }
 735                         }
 736
 737                         nvidia_read_clut(par, regno * 4, &r, &g, &b);
 738
 739                         for (i = 0; i < 4; i++)
 740                                 nvidia_write_clut(par, regno * 4 + i, r,
 741                                                   green >> 8, b);
 742                 }
 743                 break;
 744         case 32:
 745                 nvidia_write_clut(par, regno, red >> 8, green >> 8, blue >> 8);
 746                 break;
 747         default:
 748                 /* do nothing */
 749                 break;
 750         }
 751
 752         NVTRACE_LEAVE();
 753         return 0;
 754 }
 755
 756 static int nvidiafb_check_var(struct fb_var_screeninfo *var,
 757                               struct fb_info *info)
 758 {
 759         struct nvidia_par *par = info->par;
 760         int memlen, vramlen, mode_valid = 0;
 761         int pitch, err = 0;
 762
 763         NVTRACE_ENTER();
 764
 765         var->transp.offset = 0;
 766         var->transp.length = 0;
 767
 768         var->xres &= ~7;
 769
 770         if (var->bits_per_pixel <= 8)
 771                 var->bits_per_pixel = 8;
 772         else if (var->bits_per_pixel <= 16)
 773                 var->bits_per_pixel = 16;
 774         else
 775                 var->bits_per_pixel = 32;
 776
 777         switch (var->bits_per_pixel) {
 778         case 8:
 779                 var->red.offset = 0;
 780                 var->red.length = 8;
 781                 var->green.offset = 0;
 782                 var->green.length = 8;
 783                 var->blue.offset = 0;
 784                 var->blue.length = 8;
 785                 var->transp.offset = 0;
 786                 var->transp.length = 0;
 787                 break;
 788         case 16:
 789                 var->green.length = (var->green.length < 6) ? 5 : 6;
 790                 var->red.length = 5;
 791                 var->blue.length = 5;
 792                 var->transp.length = 6 - var->green.length;
 793                 var->blue.offset = 0;
 794                 var->green.offset = 5;
 795                 var->red.offset = 5 + var->green.length;
 796                 var->transp.offset = (5 + var->red.offset) & 15;
 797                 break;
 798         case 32:                /* RGBA 8888 */
 799                 var->red.offset = 16;
 800                 var->red.length = 8;
 801                 var->green.offset = 8;
 802                 var->green.length = 8;
 803                 var->blue.offset = 0;
 804                 var->blue.length = 8;
 805                 var->transp.length = 8;
 806                 var->transp.offset = 24;
 807                 break;
 808         }
 809
 810         var->red.msb_right = 0;
 811         var->green.msb_right = 0;
 812         var->blue.msb_right = 0;
 813         var->transp.msb_right = 0;
 814
 815         if (!info->monspecs.hfmax || !info->monspecs.vfmax ||
 816             !info->monspecs.dclkmax || !fb_validate_mode(var, info))
 817                 mode_valid = 1;
 818
 819         /* calculate modeline if supported by monitor */
 820         if (!mode_valid && info->monspecs.gtf) {
 821                 if (!fb_get_mode(FB_MAXTIMINGS, 0, var, info))
 822                         mode_valid = 1;
 823         }
 824
 825         if (!mode_valid) {
 826                 struct fb_videomode *mode;
 827
 828                 mode = fb_find_best_mode(var, &info->modelist);
 829                 if (mode) {
 830                         fb_videomode_to_var(var, mode);
 831                         mode_valid = 1;
 832                 }
 833         }
 834
 835         if (!mode_valid && info->monspecs.modedb_len)
 836                 return -EINVAL;
 837
 838         if (par->fpWidth && par->fpHeight && (par->fpWidth < var->xres ||
 839                                               par->fpHeight < var->yres))
 840                 return -EINVAL;
 841
 842         if (var->yres_virtual < var->yres)
 843                 var->yres_virtual = var->yres;
 844
 845         if (var->xres_virtual < var->xres)
 846                 var->xres_virtual = var->xres;
 847
 848         var->xres_virtual = (var->xres_virtual + 63) & ~63;
 849
 850         vramlen = info->screen_size;
 851         pitch = ((var->xres_virtual * var->bits_per_pixel) + 7) / 8;
 852         memlen = pitch * var->yres_virtual;
 853
 854         if (memlen > vramlen) {
 855                 var->yres_virtual = vramlen / pitch;
 856
 857                 if (var->yres_virtual < var->yres) {
 858                         var->yres_virtual = var->yres;
 859                         var->xres_virtual = vramlen / var->yres_virtual;
 860                         var->xres_virtual /= var->bits_per_pixel / 8;
 861                         var->xres_virtual &= ~63;
 862                         pitch = (var->xres_virtual *
 863                                  var->bits_per_pixel + 7) / 8;
 864                         memlen = pitch * var->yres;
 865
 866                         if (var->xres_virtual < var->xres) {
 867                                 printk("nvidiafb: required video memory, "
 868                                        "%d bytes, for %dx%d-%d (virtual) "
 869                                        "is out of range\n",
 870                                        memlen, var->xres_virtual,
 871                                        var->yres_virtual, var->bits_per_pixel);
 872                                 err = -ENOMEM;
 873                         }
 874                 }
 875         }
 876
 877         if (var->accel_flags) {
 878                 if (var->yres_virtual > 0x7fff)
 879                         var->yres_virtual = 0x7fff;
 880                 if (var->xres_virtual > 0x7fff)
 881                         var->xres_virtual = 0x7fff;
 882         }
 883
 884         var->xres_virtual &= ~63;
 885
 886         NVTRACE_LEAVE();
 887
 888         return err;
 889 }
 890
 891 static int nvidiafb_pan_display(struct fb_var_screeninfo *var,
 892                                 struct fb_info *info)
 893 {
 894         struct nvidia_par *par = info->par;
 895         u32 total;
 896
 897         total = var->yoffset * info->fix.line_length + var->xoffset;
 898
 899         NVSetStartAddress(par, total);
 900
 901         return 0;
 902 }
 903
 904 static int nvidiafb_blank(int blank, struct fb_info *info)
 905 {
 906         struct nvidia_par *par = info->par;
 907         unsigned char tmp, vesa;
 908
 909         tmp = NVReadSeq(par, 0x01) & ~0x20;     /* screen on/off */
 910         vesa = NVReadCrtc(par, 0x1a) & ~0xc0;   /* sync on/off */
 911
 912         NVTRACE_ENTER();
 913
 914         if (blank)
 915                 tmp |= 0x20;
 916
 917         switch (blank) {
 918         case FB_BLANK_UNBLANK:
 919         case FB_BLANK_NORMAL:
 920                 break;
 921         case FB_BLANK_VSYNC_SUSPEND:
 922                 vesa |= 0x80;
 923                 break;
 924         case FB_BLANK_HSYNC_SUSPEND:
 925                 vesa |= 0x40;
 926                 break;
 927         case FB_BLANK_POWERDOWN:
 928                 vesa |= 0xc0;
 929                 break;
 930         }
 931
 932         NVWriteSeq(par, 0x01, tmp);
 933         NVWriteCrtc(par, 0x1a, vesa);
 934
 935         nvidia_bl_set_power(info, blank);
 936
 937         NVTRACE_LEAVE();
 938
 939         return 0;
 940 }
 941
 942 static struct fb_ops nvidia_fb_ops = {
 943         .owner          = THIS_MODULE,
 944         .fb_check_var   = nvidiafb_check_var,
 945         .fb_set_par     = nvidiafb_set_par,
 946         .fb_setcolreg   = nvidiafb_setcolreg,
 947         .fb_pan_display = nvidiafb_pan_display,
 948         .fb_blank       = nvidiafb_blank,
 949         .fb_fillrect    = nvidiafb_fillrect,
 950         .fb_copyarea    = nvidiafb_copyarea,
 951         .fb_imageblit   = nvidiafb_imageblit,
 952         .fb_cursor      = nvidiafb_cursor,
 953         .fb_sync        = nvidiafb_sync,
 954 };
 955
 956 #ifdef CONFIG_PM
 957 static int nvidiafb_suspend(struct pci_dev *dev, pm_message_t state)
 958 {
 959         struct fb_info *info = pci_get_drvdata(dev);
 960         struct nvidia_par *par = info->par;
 961
 962         acquire_console_sem();
 963         par->pm_state = state.event;
 964
 965         if (state.event == PM_EVENT_FREEZE) {
 966                 dev->dev.power.power_state = state;
 967         } else {
 968                 fb_set_suspend(info, 1);
 969                 nvidiafb_blank(FB_BLANK_POWERDOWN, info);
 970                 nvidia_write_regs(par, &par->SavedReg);
 971                 pci_save_state(dev);
 972                 pci_disable_device(dev);
 973                 pci_set_power_state(dev, pci_choose_state(dev, state));
 974         }
 975
 976         release_console_sem();
 977         return 0;
 978 }
 979
 980 static int nvidiafb_resume(struct pci_dev *dev)
 981 {
 982         struct fb_info *info = pci_get_drvdata(dev);
 983         struct nvidia_par *par = info->par;
 984
 985         acquire_console_sem();
 986         pci_set_power_state(dev, PCI_D0);
 987
 988         if (par->pm_state != PM_EVENT_FREEZE) {
 989                 pci_restore_state(dev);
 990                 pci_enable_device(dev);
 991                 pci_set_master(dev);
 992         }
 993
 994         par->pm_state = PM_EVENT_ON;
 995         nvidiafb_set_par(info);
 996         fb_set_suspend (info, 0);
 997         nvidiafb_blank(FB_BLANK_UNBLANK, info);
 998
 999         release_console_sem();
1000         return 0;
1001 }
1002 #else
1003 #define nvidiafb_suspend NULL
1004 #define nvidiafb_resume NULL
1005 #endif
1006
1007 static int __devinit nvidia_set_fbinfo(struct fb_info *info)
1008 {
1009         struct fb_monspecs *specs = &info->monspecs;
1010         struct fb_videomode modedb;
1011         struct nvidia_par *par = info->par;
1012         int lpitch;
1013
1014         NVTRACE_ENTER();
1015         info->flags = FBINFO_DEFAULT
1016             | FBINFO_HWACCEL_IMAGEBLIT
1017             | FBINFO_HWACCEL_FILLRECT
1018             | FBINFO_HWACCEL_COPYAREA
1019             | FBINFO_HWACCEL_YPAN;
1020
1021         fb_videomode_to_modelist(info->monspecs.modedb,
1022                                  info->monspecs.modedb_len, &info->modelist);
1023         fb_var_to_videomode(&modedb, &nvidiafb_default_var);
1024
1025         switch (bpp) {
1026         case 0 ... 8:
1027                 bpp = 8;
1028                 break;
1029         case 9 ... 16:
1030                 bpp = 16;
1031                 break;
1032         default:
1033                 bpp = 32;
1034                 break;
1035         }
1036
1037         if (specs->modedb != NULL) {
1038                 struct fb_videomode *modedb;
1039
1040                 modedb = fb_find_best_display(specs, &info->modelist);
1041                 fb_videomode_to_var(&nvidiafb_default_var, modedb);
1042                 nvidiafb_default_var.bits_per_pixel = bpp;
1043         } else if (par->fpWidth && par->fpHeight) {
1044                 char buf[16];
1045
1046                 memset(buf, 0, 16);
1047                 snprintf(buf, 15, "%dx%dMR", par->fpWidth, par->fpHeight);
1048                 fb_find_mode(&nvidiafb_default_var, info, buf, specs->modedb,
1049                              specs->modedb_len, &modedb, bpp);
1050         }
1051
1052         if (mode_option)
1053                 fb_find_mode(&nvidiafb_default_var, info, mode_option,
1054                              specs->modedb, specs->modedb_len, &modedb, bpp);
1055
1056         info->var = nvidiafb_default_var;
1057         info->fix.visual = (info->var.bits_per_pixel == 8) ?
1058                 FB_VISUAL_PSEUDOCOLOR : FB_VISUAL_DIRECTCOLOR;
1059         info->pseudo_palette = par->pseudo_palette;
1060         fb_alloc_cmap(&info->cmap, 256, 0);
1061         fb_destroy_modedb(info->monspecs.modedb);
1062         info->monspecs.modedb = NULL;
1063
1064         /* maximize virtual vertical length */
1065         lpitch = info->var.xres_virtual *
1066                 ((info->var.bits_per_pixel + 7) >> 3);
1067         info->var.yres_virtual = info->screen_size / lpitch;
1068
1069         info->pixmap.scan_align = 4;
1070         info->pixmap.buf_align = 4;
1071         info->pixmap.access_align = 32;
1072         info->pixmap.size = 8 * 1024;
1073         info->pixmap.flags = FB_PIXMAP_SYSTEM;
1074
1075         if (!hwcur)
1076             info->fbops->fb_cursor = NULL;
1077
1078         info->var.accel_flags = (!noaccel);
1079
1080         switch (par->Architecture) {
1081         case NV_ARCH_04:
1082                 info->fix.accel = FB_ACCEL_NV4;
1083                 break;
1084         case NV_ARCH_10:
1085                 info->fix.accel = FB_ACCEL_NV_10;
1086                 break;
1087         case NV_ARCH_20:
1088                 info->fix.accel = FB_ACCEL_NV_20;
1089                 break;
1090         case NV_ARCH_30:
1091                 info->fix.accel = FB_ACCEL_NV_30;
1092                 break;
1093         case NV_ARCH_40:
1094                 info->fix.accel = FB_ACCEL_NV_40;
1095                 break;
1096         }
1097
1098         NVTRACE_LEAVE();
1099
1100         return nvidiafb_check_var(&info->var, info);
1101 }
1102
1103 static u32 __devinit nvidia_get_chipset(struct fb_info *info)
1104 {
1105         struct nvidia_par *par = info->par;
1106         u32 id = (par->pci_dev->vendor << 16) | par->pci_dev->device;
1107
1108         printk(KERN_INFO PFX "Device ID: %x \n", id);
1109
1110         if ((id & 0xfff0) == 0x00f0) {
1111                 /* pci-e */
1112                 id = NV_RD32(par->REGS, 0x1800);
1113
1114                 if ((id & 0x0000ffff) == 0x000010DE)
1115                         id = 0x10DE0000 | (id >> 16);
1116                 else if ((id & 0xffff0000) == 0xDE100000) /* wrong endian */
1117                         id = 0x10DE0000 | ((id << 8) & 0x0000ff00) |
1118                             ((id >> 8) & 0x000000ff);
1119                 printk(KERN_INFO PFX "Subsystem ID: %x \n", id);
1120         }
1121
1122         return id;
1123 }
1124
1125 static u32 __devinit nvidia_get_arch(struct fb_info *info)
1126 {
1127         struct nvidia_par *par = info->par;
1128         u32 arch = 0;
1129
1130         switch (par->Chipset & 0x0ff0) {
1131         case 0x0100:            /* GeForce 256 */
1132         case 0x0110:            /* GeForce2 MX */
1133         case 0x0150:            /* GeForce2 */
1134         case 0x0170:            /* GeForce4 MX */
1135         case 0x0180:            /* GeForce4 MX (8x AGP) */
1136         case 0x01A0:            /* nForce */
1137         case 0x01F0:            /* nForce2 */
1138                 arch = NV_ARCH_10;
1139                 break;
1140         case 0x0200:            /* GeForce3 */
1141         case 0x0250:            /* GeForce4 Ti */
1142         case 0x0280:            /* GeForce4 Ti (8x AGP) */
1143                 arch = NV_ARCH_20;
1144                 break;
1145         case 0x0300:            /* GeForceFX 5800 */
1146         case 0x0310:            /* GeForceFX 5600 */
1147         case 0x0320:            /* GeForceFX 5200 */
1148         case 0x0330:            /* GeForceFX 5900 */
1149         case 0x0340:            /* GeForceFX 5700 */
1150                 arch = NV_ARCH_30;
1151                 break;
1152         case 0x0040:
1153         case 0x00C0:
1154         case 0x0120:
1155         case 0x0130:
1156         case 0x0140:
1157         case 0x0160:
1158         case 0x01D0:
1159         case 0x0090:
1160         case 0x0210:
1161         case 0x0220:
1162         case 0x0230:
1163         case 0x0240:
1164         case 0x0290:
1165         case 0x0390:
1166                 arch = NV_ARCH_40;
1167                 break;
1168         case 0x0020:            /* TNT, TNT2 */
1169                 arch = NV_ARCH_04;
1170                 break;
1171         default:                /* unknown architecture */
1172                 break;
1173         }
1174
1175         return arch;
1176 }
1177
1178 static int __devinit nvidiafb_probe(struct pci_dev *pd,
1179                                     const struct pci_device_id *ent)
1180 {
1181         struct nvidia_par *par;
1182         struct fb_info *info;
1183         unsigned short cmd;
1184
1185
1186         NVTRACE_ENTER();
1187         assert(pd != NULL);
1188
1189         info = framebuffer_alloc(sizeof(struct nvidia_par), &pd->dev);
1190
1191         if (!info)
1192                 goto err_out;
1193
1194         par = info->par;
1195         par->pci_dev = pd;
1196
1197         info->pixmap.addr = kmalloc(8 * 1024, GFP_KERNEL);
1198
1199         if (info->pixmap.addr == NULL)
1200                 goto err_out_kfree;
1201
1202         memset(info->pixmap.addr, 0, 8 * 1024);
1203
1204         if (pci_enable_device(pd)) {
1205                 printk(KERN_ERR PFX "cannot enable PCI device\n");
1206                 goto err_out_enable;
1207         }
1208
1209         if (pci_request_regions(pd, "nvidiafb")) {
1210                 printk(KERN_ERR PFX "cannot request PCI regions\n");
1211                 goto err_out_enable;
1212         }
1213
1214         par->FlatPanel = flatpanel;
1215         if (flatpanel == 1)
1216                 printk(KERN_INFO PFX "flatpanel support enabled\n");
1217         par->FPDither = fpdither;
1218
1219         par->CRTCnumber = forceCRTC;
1220         par->FpScale = (!noscale);
1221         par->paneltweak = paneltweak;
1222
1223         /* enable IO and mem if not already done */
1224         pci_read_config_word(pd, PCI_COMMAND, &cmd);
1225         cmd |= (PCI_COMMAND_IO | PCI_COMMAND_MEMORY);
1226         pci_write_config_word(pd, PCI_COMMAND, cmd);
1227
1228         nvidiafb_fix.mmio_start = pci_resource_start(pd, 0);
1229         nvidiafb_fix.smem_start = pci_resource_start(pd, 1);
1230         nvidiafb_fix.mmio_len = pci_resource_len(pd, 0);
1231
1232         par->REGS = ioremap(nvidiafb_fix.mmio_start, nvidiafb_fix.mmio_len);
1233
1234         if (!par->REGS) {
1235                 printk(KERN_ERR PFX "cannot ioremap MMIO base\n");
1236                 goto err_out_free_base0;
1237         }
1238
1239         par->Chipset = nvidia_get_chipset(info);
1240         par->Architecture = nvidia_get_arch(info);
1241
1242         if (par->Architecture == 0) {
1243                 printk(KERN_ERR PFX "unknown NV_ARCH\n");
1244                 goto err_out_arch;
1245         }
1246
1247         sprintf(nvidiafb_fix.id, "NV%x", (pd->device & 0x0ff0) >> 4);
1248
1249         if (NVCommonSetup(info))
1250                 goto err_out_arch;
1251
1252         par->FbAddress = nvidiafb_fix.smem_start;
1253         par->FbMapSize = par->RamAmountKBytes * 1024;
1254         if (vram && vram * 1024 * 1024 < par->FbMapSize)
1255                 par->FbMapSize = vram * 1024 * 1024;
1256
1257         /* Limit amount of vram to 64 MB */
1258         if (par->FbMapSize > 64 * 1024 * 1024)
1259                 par->FbMapSize = 64 * 1024 * 1024;
1260
1261         if(par->Architecture >= NV_ARCH_40)
1262                 par->FbUsableSize = par->FbMapSize - (560 * 1024);
1263         else
1264                 par->FbUsableSize = par->FbMapSize - (128 * 1024);
1265         par->ScratchBufferSize = (par->Architecture < NV_ARCH_10) ? 8 * 1024 :
1266             16 * 1024;
1267         par->ScratchBufferStart = par->FbUsableSize - par->ScratchBufferSize;
1268         par->CursorStart = par->FbUsableSize + (32 * 1024);
1269
1270         info->screen_base = ioremap(nvidiafb_fix.smem_start, par->FbMapSize);
1271         info->screen_size = par->FbUsableSize;
1272         nvidiafb_fix.smem_len = par->RamAmountKBytes * 1024;
1273
1274         if (!info->screen_base) {
1275                 printk(KERN_ERR PFX "cannot ioremap FB base\n");
1276                 goto err_out_free_base1;
1277         }
1278
1279         par->FbStart = info->screen_base;
1280
1281 #ifdef CONFIG_MTRR
1282         if (!nomtrr) {
1283                 par->mtrr.vram = mtrr_add(nvidiafb_fix.smem_start,
1284                                           par->RamAmountKBytes * 1024,
1285                                           MTRR_TYPE_WRCOMB, 1);
1286                 if (par->mtrr.vram < 0) {
1287                         printk(KERN_ERR PFX "unable to setup MTRR\n");
1288                 } else {
1289                         par->mtrr.vram_valid = 1;
1290                         /* let there be speed */
1291                         printk(KERN_INFO PFX "MTRR set to ON\n");
1292                 }
1293         }
1294 #endif                          /* CONFIG_MTRR */
1295
1296         info->fbops = &nvidia_fb_ops;
1297         info->fix = nvidiafb_fix;
1298
1299         if (nvidia_set_fbinfo(info) < 0) {
1300                 printk(KERN_ERR PFX "error setting initial video mode\n");
1301                 goto err_out_iounmap_fb;
1302         }
1303
1304         nvidia_save_vga(par, &par->SavedReg);
1305
1306         if (register_framebuffer(info) < 0) {
1307                 printk(KERN_ERR PFX "error registering nVidia framebuffer\n");
1308                 goto err_out_iounmap_fb;
1309         }
1310
1311         pci_set_drvdata(pd, info);
1312
1313         printk(KERN_INFO PFX
1314                "PCI nVidia %s framebuffer (%dMB @ 0x%lX)\n",
1315                info->fix.id,
1316                par->FbMapSize / (1024 * 1024), info->fix.smem_start);
1317
1318         nvidia_bl_init(par);
1319
1320         NVTRACE_LEAVE();
1321         return 0;
1322
1323 err_out_iounmap_fb:
1324         iounmap(info->screen_base);
1325 err_out_free_base1:
1326         fb_destroy_modedb(info->monspecs.modedb);
1327         nvidia_delete_i2c_busses(par);
1328 err_out_arch:
1329         iounmap(par->REGS);
1330  err_out_free_base0:
1331         pci_release_regions(pd);
1332 err_out_enable:
1333         kfree(info->pixmap.addr);
1334 err_out_kfree:
1335         framebuffer_release(info);
1336 err_out:
1337         return -ENODEV;
1338 }
1339
1340 static void __exit nvidiafb_remove(struct pci_dev *pd)
1341 {
1342         struct fb_info *info = pci_get_drvdata(pd);
1343         struct nvidia_par *par = info->par;
1344
1345         NVTRACE_ENTER();
1346
1347         nvidia_bl_exit(par);
1348
1349         unregister_framebuffer(info);
1350 #ifdef CONFIG_MTRR
1351         if (par->mtrr.vram_valid)
1352                 mtrr_del(par->mtrr.vram, info->fix.smem_start,
1353                          info->fix.smem_len);
1354 #endif                          /* CONFIG_MTRR */
1355
1356         iounmap(info->screen_base);
1357         fb_destroy_modedb(info->monspecs.modedb);
1358         nvidia_delete_i2c_busses(par);
1359         iounmap(par->REGS);
1360         pci_release_regions(pd);
1361         kfree(info->pixmap.addr);
1362         framebuffer_release(info);
1363         pci_set_drvdata(pd, NULL);
1364         NVTRACE_LEAVE();
1365 }
1366
1367 /* ------------------------------------------------------------------------- *
1368  *
1369  * initialization
1370  *
1371  * ------------------------------------------------------------------------- */
1372
1373 #ifndef MODULE
1374 static int __devinit nvidiafb_setup(char *options)
1375 {
1376         char *this_opt;
1377
1378         NVTRACE_ENTER();
1379         if (!options || !*options)
1380                 return 0;
1381
1382         while ((this_opt = strsep(&options, ",")) != NULL) {
1383                 if (!strncmp(this_opt, "forceCRTC", 9)) {
1384                         char *p;
1385
1386                         p = this_opt + 9;
1387                         if (!*p || !*(++p))
1388                                 continue;
1389                         forceCRTC = *p - '0';
1390                         if (forceCRTC < 0 || forceCRTC > 1)
1391                                 forceCRTC = -1;
1392                 } else if (!strncmp(this_opt, "flatpanel", 9)) {
1393                         flatpanel = 1;
1394                 } else if (!strncmp(this_opt, "hwcur", 5)) {
1395                         hwcur = 1;
1396                 } else if (!strncmp(this_opt, "noaccel", 6)) {
1397                         noaccel = 1;
1398                 } else if (!strncmp(this_opt, "noscale", 7)) {
1399                         noscale = 1;
1400                 } else if (!strncmp(this_opt, "paneltweak:", 11)) {
1401                         paneltweak = simple_strtoul(this_opt+11, NULL, 0);
1402                 } else if (!strncmp(this_opt, "vram:", 5)) {
1403                         vram = simple_strtoul(this_opt+5, NULL, 0);
1404 #ifdef CONFIG_MTRR
1405                 } else if (!strncmp(this_opt, "nomtrr", 6)) {
1406                         nomtrr = 1;
1407 #endif
1408                 } else if (!strncmp(this_opt, "fpdither:", 9)) {
1409                         fpdither = simple_strtol(this_opt+9, NULL, 0);
1410                 } else if (!strncmp(this_opt, "bpp:", 4)) {
1411                         bpp = simple_strtoul(this_opt+4, NULL, 0);
1412                 } else
1413                         mode_option = this_opt;
1414         }
1415         NVTRACE_LEAVE();
1416         return 0;
1417 }
1418 #endif                          /* !MODULE */
1419
1420 static struct pci_driver nvidiafb_driver = {
1421         .name = "nvidiafb",
1422         .id_table = nvidiafb_pci_tbl,
1423         .probe    = nvidiafb_probe,
1424         .suspend  = nvidiafb_suspend,
1425         .resume   = nvidiafb_resume,
1426         .remove   = __exit_p(nvidiafb_remove),
1427 };
1428
1429 /* ------------------------------------------------------------------------- *
1430  *
1431  * modularization
1432  *
1433  * ------------------------------------------------------------------------- */
1434
1435 static int __devinit nvidiafb_init(void)
1436 {
1437 #ifndef MODULE
1438         char *option = NULL;
1439
1440         if (fb_get_options("nvidiafb", &option))
1441                 return -ENODEV;
1442         nvidiafb_setup(option);
1443 #endif
1444         return pci_register_driver(&nvidiafb_driver);
1445 }
1446
1447 module_init(nvidiafb_init);
1448
1449 #ifdef MODULE
1450 static void __exit nvidiafb_exit(void)
1451 {
1452         pci_unregister_driver(&nvidiafb_driver);
1453 }
1454
1455 module_exit(nvidiafb_exit);
1456
1457 module_param(flatpanel, int, 0);
1458 MODULE_PARM_DESC(flatpanel,
1459                  "Enables experimental flat panel support for some chipsets. "
1460                  "(0=disabled, 1=enabled, -1=autodetect) (default=-1)");
1461 module_param(fpdither, int, 0);
1462 MODULE_PARM_DESC(fpdither,
1463                  "Enables dithering of flat panel for 6 bits panels. "
1464                  "(0=disabled, 1=enabled, -1=autodetect) (default=-1)");
1465 module_param(hwcur, int, 0);
1466 MODULE_PARM_DESC(hwcur,
1467                  "Enables hardware cursor implementation. (0 or 1=enabled) "
1468                  "(default=0)");
1469 module_param(noaccel, int, 0);
1470 MODULE_PARM_DESC(noaccel,
1471                  "Disables hardware acceleration. (0 or 1=disable) "
1472                  "(default=0)");
1473 module_param(noscale, int, 0);
1474 MODULE_PARM_DESC(noscale,
1475                  "Disables screen scaleing. (0 or 1=disable) "
1476                  "(default=0, do scaling)");
1477 module_param(paneltweak, int, 0);
1478 MODULE_PARM_DESC(paneltweak,
1479                  "Tweak display settings for flatpanels. "
1480                  "(default=0, no tweaks)");
1481 module_param(forceCRTC, int, 0);
1482 MODULE_PARM_DESC(forceCRTC,
1483                  "Forces usage of a particular CRTC in case autodetection "
1484                  "fails. (0 or 1) (default=autodetect)");
1485 module_param(vram, int, 0);
1486 MODULE_PARM_DESC(vram,
1487                  "amount of framebuffer memory to remap in MiB"
1488                  "(default=0 - remap entire memory)");
1489 module_param(mode_option, charp, 0);
1490 MODULE_PARM_DESC(mode_option, "Specify initial video mode");
1491 module_param(bpp, int, 0);
1492 MODULE_PARM_DESC(bpp, "pixel width in bits"
1493                  "(default=8)");
1494 #ifdef CONFIG_MTRR
1495 module_param(nomtrr, bool, 0);
1496 MODULE_PARM_DESC(nomtrr, "Disables MTRR support (0 or 1=disabled) "
1497                  "(default=0)");
1498 #endif
1499
1500 MODULE_AUTHOR("Antonino Daplas");
1501 MODULE_DESCRIPTION("Framebuffer driver for nVidia graphics chipset");
1502 MODULE_LICENSE("GPL");
1503 #endif                          /* MODULE */
1504