git.oblomov.eu Git - linux-2.6/blob - drivers/video/gbefb.c

   1 /*
   2  *  SGI GBE frame buffer driver
   3  *
   4  *  Copyright (C) 1999 Silicon Graphics, Inc. - Jeffrey Newquist
   5  *  Copyright (C) 2002 Vivien Chappelier <vivien.chappelier@linux-mips.org>
   6  *
   7  *  This file is subject to the terms and conditions of the GNU General Public
   8  *  License. See the file COPYING in the main directory of this archive for
   9  *  more details.
  10  */
  11
  12 #include <linux/delay.h>
  13 #include <linux/platform_device.h>
  14 #include <linux/dma-mapping.h>
  15 #include <linux/errno.h>
  16 #include <linux/fb.h>
  17 #include <linux/init.h>
  18 #include <linux/interrupt.h>
  19 #include <linux/kernel.h>
  20 #include <linux/mm.h>
  21 #include <linux/module.h>
  22
  23 #ifdef CONFIG_X86
  24 #include <asm/mtrr.h>
  25 #endif
  26 #ifdef CONFIG_MIPS
  27 #include <asm/addrspace.h>
  28 #endif
  29 #include <asm/byteorder.h>
  30 #include <asm/io.h>
  31 #include <asm/tlbflush.h>
  32
  33 #include <video/gbe.h>
  34
  35 static struct sgi_gbe *gbe;
  36
  37 struct gbefb_par {
  38         struct fb_var_screeninfo var;
  39         struct gbe_timing_info timing;
  40         int valid;
  41 };
  42
  43 #ifdef CONFIG_SGI_IP32
  44 #define GBE_BASE        0x16000000 /* SGI O2 */
  45 #endif
  46
  47 #ifdef CONFIG_X86_VISWS
  48 #define GBE_BASE        0xd0000000 /* SGI Visual Workstation */
  49 #endif
  50
  51 /* macro for fastest write-though access to the framebuffer */
  52 #ifdef CONFIG_MIPS
  53 #ifdef CONFIG_CPU_R10000
  54 #define pgprot_fb(_prot) (((_prot) & (~_CACHE_MASK)) | _CACHE_UNCACHED_ACCELERATED)
  55 #else
  56 #define pgprot_fb(_prot) (((_prot) & (~_CACHE_MASK)) | _CACHE_CACHABLE_NO_WA)
  57 #endif
  58 #endif
  59 #ifdef CONFIG_X86
  60 #define pgprot_fb(_prot) ((_prot) | _PAGE_PCD)
  61 #endif
  62
  63 /*
  64  *  RAM we reserve for the frame buffer. This defines the maximum screen
  65  *  size
  66  */
  67 #if CONFIG_FB_GBE_MEM > 8
  68 #error GBE Framebuffer cannot use more than 8MB of memory
  69 #endif
  70
  71 #define TILE_SHIFT 16
  72 #define TILE_SIZE (1 << TILE_SHIFT)
  73 #define TILE_MASK (TILE_SIZE - 1)
  74
  75 static unsigned int gbe_mem_size = CONFIG_FB_GBE_MEM * 1024*1024;
  76 static void *gbe_mem;
  77 static dma_addr_t gbe_dma_addr;
  78 unsigned long gbe_mem_phys;
  79
  80 static struct {
  81         uint16_t *cpu;
  82         dma_addr_t dma;
  83 } gbe_tiles;
  84
  85 static int gbe_revision;
  86
  87 static int ypan, ywrap;
  88
  89 static uint32_t pseudo_palette[256];
  90
  91 static char *mode_option __initdata = NULL;
  92
  93 /* default CRT mode */
  94 static struct fb_var_screeninfo default_var_CRT __initdata = {
  95         /* 640x480, 60 Hz, Non-Interlaced (25.175 MHz dotclock) */
  96         .xres           = 640,
  97         .yres           = 480,
  98         .xres_virtual   = 640,
  99         .yres_virtual   = 480,
 100         .xoffset        = 0,
 101         .yoffset        = 0,
 102         .bits_per_pixel = 8,
 103         .grayscale      = 0,
 104         .red            = { 0, 8, 0 },
 105         .green          = { 0, 8, 0 },
 106         .blue           = { 0, 8, 0 },
 107         .transp         = { 0, 0, 0 },
 108         .nonstd         = 0,
 109         .activate       = 0,
 110         .height         = -1,
 111         .width          = -1,
 112         .accel_flags    = 0,
 113         .pixclock       = 39722,        /* picoseconds */
 114         .left_margin    = 48,
 115         .right_margin   = 16,
 116         .upper_margin   = 33,
 117         .lower_margin   = 10,
 118         .hsync_len      = 96,
 119         .vsync_len      = 2,
 120         .sync           = 0,
 121         .vmode          = FB_VMODE_NONINTERLACED,
 122 };
 123
 124 /* default LCD mode */
 125 static struct fb_var_screeninfo default_var_LCD __initdata = {
 126         /* 1600x1024, 8 bpp */
 127         .xres           = 1600,
 128         .yres           = 1024,
 129         .xres_virtual   = 1600,
 130         .yres_virtual   = 1024,
 131         .xoffset        = 0,
 132         .yoffset        = 0,
 133         .bits_per_pixel = 8,
 134         .grayscale      = 0,
 135         .red            = { 0, 8, 0 },
 136         .green          = { 0, 8, 0 },
 137         .blue           = { 0, 8, 0 },
 138         .transp         = { 0, 0, 0 },
 139         .nonstd         = 0,
 140         .activate       = 0,
 141         .height         = -1,
 142         .width          = -1,
 143         .accel_flags    = 0,
 144         .pixclock       = 9353,
 145         .left_margin    = 20,
 146         .right_margin   = 30,
 147         .upper_margin   = 37,
 148         .lower_margin   = 3,
 149         .hsync_len      = 20,
 150         .vsync_len      = 3,
 151         .sync           = 0,
 152         .vmode          = FB_VMODE_NONINTERLACED
 153 };
 154
 155 /* default modedb mode */
 156 /* 640x480, 60 Hz, Non-Interlaced (25.172 MHz dotclock) */
 157 static struct fb_videomode default_mode_CRT __initdata = {
 158         .refresh        = 60,
 159         .xres           = 640,
 160         .yres           = 480,
 161         .pixclock       = 39722,
 162         .left_margin    = 48,
 163         .right_margin   = 16,
 164         .upper_margin   = 33,
 165         .lower_margin   = 10,
 166         .hsync_len      = 96,
 167         .vsync_len      = 2,
 168         .sync           = 0,
 169         .vmode          = FB_VMODE_NONINTERLACED,
 170 };
 171 /* 1600x1024 SGI flatpanel 1600sw */
 172 static struct fb_videomode default_mode_LCD __initdata = {
 173         /* 1600x1024, 8 bpp */
 174         .xres           = 1600,
 175         .yres           = 1024,
 176         .pixclock       = 9353,
 177         .left_margin    = 20,
 178         .right_margin   = 30,
 179         .upper_margin   = 37,
 180         .lower_margin   = 3,
 181         .hsync_len      = 20,
 182         .vsync_len      = 3,
 183         .vmode          = FB_VMODE_NONINTERLACED,
 184 };
 185
 186 struct fb_videomode *default_mode = &default_mode_CRT;
 187 struct fb_var_screeninfo *default_var = &default_var_CRT;
 188
 189 static int flat_panel_enabled = 0;
 190
 191 static void gbe_reset(void)
 192 {
 193         /* Turn on dotclock PLL */
 194         gbe->ctrlstat = 0x300aa000;
 195 }
 196
 197
 198 /*
 199  * Function:    gbe_turn_off
 200  * Parameters:  (None)
 201  * Description: This should turn off the monitor and gbe.  This is used
 202  *              when switching between the serial console and the graphics
 203  *              console.
 204  */
 205
 206 void gbe_turn_off(void)
 207 {
 208         int i;
 209         unsigned int val, x, y, vpixen_off;
 210
 211         /* check if pixel counter is on */
 212         val = gbe->vt_xy;
 213         if (GET_GBE_FIELD(VT_XY, FREEZE, val) == 1)
 214                 return;
 215
 216         /* turn off DMA */
 217         val = gbe->ovr_control;
 218         SET_GBE_FIELD(OVR_CONTROL, OVR_DMA_ENABLE, val, 0);
 219         gbe->ovr_control = val;
 220         udelay(1000);
 221         val = gbe->frm_control;
 222         SET_GBE_FIELD(FRM_CONTROL, FRM_DMA_ENABLE, val, 0);
 223         gbe->frm_control = val;
 224         udelay(1000);
 225         val = gbe->did_control;
 226         SET_GBE_FIELD(DID_CONTROL, DID_DMA_ENABLE, val, 0);
 227         gbe->did_control = val;
 228         udelay(1000);
 229
 230         /* We have to wait through two vertical retrace periods before
 231          * the pixel DMA is turned off for sure. */
 232         for (i = 0; i < 10000; i++) {
 233                 val = gbe->frm_inhwctrl;
 234                 if (GET_GBE_FIELD(FRM_INHWCTRL, FRM_DMA_ENABLE, val)) {
 235                         udelay(10);
 236                 } else {
 237                         val = gbe->ovr_inhwctrl;
 238                         if (GET_GBE_FIELD(OVR_INHWCTRL, OVR_DMA_ENABLE, val)) {
 239                                 udelay(10);
 240                         } else {
 241                                 val = gbe->did_inhwctrl;
 242                                 if (GET_GBE_FIELD(DID_INHWCTRL, DID_DMA_ENABLE, val)) {
 243                                         udelay(10);
 244                                 } else
 245                                         break;
 246                         }
 247                 }
 248         }
 249         if (i == 10000)
 250                 printk(KERN_ERR "gbefb: turn off DMA timed out\n");
 251
 252         /* wait for vpixen_off */
 253         val = gbe->vt_vpixen;
 254         vpixen_off = GET_GBE_FIELD(VT_VPIXEN, VPIXEN_OFF, val);
 255
 256         for (i = 0; i < 100000; i++) {
 257                 val = gbe->vt_xy;
 258                 x = GET_GBE_FIELD(VT_XY, X, val);
 259                 y = GET_GBE_FIELD(VT_XY, Y, val);
 260                 if (y < vpixen_off)
 261                         break;
 262                 udelay(1);
 263         }
 264         if (i == 100000)
 265                 printk(KERN_ERR
 266                        "gbefb: wait for vpixen_off timed out\n");
 267         for (i = 0; i < 10000; i++) {
 268                 val = gbe->vt_xy;
 269                 x = GET_GBE_FIELD(VT_XY, X, val);
 270                 y = GET_GBE_FIELD(VT_XY, Y, val);
 271                 if (y > vpixen_off)
 272                         break;
 273                 udelay(1);
 274         }
 275         if (i == 10000)
 276                 printk(KERN_ERR "gbefb: wait for vpixen_off timed out\n");
 277
 278         /* turn off pixel counter */
 279         val = 0;
 280         SET_GBE_FIELD(VT_XY, FREEZE, val, 1);
 281         gbe->vt_xy = val;
 282         udelay(10000);
 283         for (i = 0; i < 10000; i++) {
 284                 val = gbe->vt_xy;
 285                 if (GET_GBE_FIELD(VT_XY, FREEZE, val) != 1)
 286                         udelay(10);
 287                 else
 288                         break;
 289         }
 290         if (i == 10000)
 291                 printk(KERN_ERR "gbefb: turn off pixel clock timed out\n");
 292
 293         /* turn off dot clock */
 294         val = gbe->dotclock;
 295         SET_GBE_FIELD(DOTCLK, RUN, val, 0);
 296         gbe->dotclock = val;
 297         udelay(10000);
 298         for (i = 0; i < 10000; i++) {
 299                 val = gbe->dotclock;
 300                 if (GET_GBE_FIELD(DOTCLK, RUN, val))
 301                         udelay(10);
 302                 else
 303                         break;
 304         }
 305         if (i == 10000)
 306                 printk(KERN_ERR "gbefb: turn off dotclock timed out\n");
 307
 308         /* reset the frame DMA FIFO */
 309         val = gbe->frm_size_tile;
 310         SET_GBE_FIELD(FRM_SIZE_TILE, FRM_FIFO_RESET, val, 1);
 311         gbe->frm_size_tile = val;
 312         SET_GBE_FIELD(FRM_SIZE_TILE, FRM_FIFO_RESET, val, 0);
 313         gbe->frm_size_tile = val;
 314 }
 315
 316 static void gbe_turn_on(void)
 317 {
 318         unsigned int val, i;
 319
 320         /*
 321          * Check if pixel counter is off, for unknown reason this
 322          * code hangs Visual Workstations
 323          */
 324         if (gbe_revision < 2) {
 325                 val = gbe->vt_xy;
 326                 if (GET_GBE_FIELD(VT_XY, FREEZE, val) == 0)
 327                         return;
 328         }
 329
 330         /* turn on dot clock */
 331         val = gbe->dotclock;
 332         SET_GBE_FIELD(DOTCLK, RUN, val, 1);
 333         gbe->dotclock = val;
 334         udelay(10000);
 335         for (i = 0; i < 10000; i++) {
 336                 val = gbe->dotclock;
 337                 if (GET_GBE_FIELD(DOTCLK, RUN, val) != 1)
 338                         udelay(10);
 339                 else
 340                         break;
 341         }
 342         if (i == 10000)
 343                 printk(KERN_ERR "gbefb: turn on dotclock timed out\n");
 344
 345         /* turn on pixel counter */
 346         val = 0;
 347         SET_GBE_FIELD(VT_XY, FREEZE, val, 0);
 348         gbe->vt_xy = val;
 349         udelay(10000);
 350         for (i = 0; i < 10000; i++) {
 351                 val = gbe->vt_xy;
 352                 if (GET_GBE_FIELD(VT_XY, FREEZE, val))
 353                         udelay(10);
 354                 else
 355                         break;
 356         }
 357         if (i == 10000)
 358                 printk(KERN_ERR "gbefb: turn on pixel clock timed out\n");
 359
 360         /* turn on DMA */
 361         val = gbe->frm_control;
 362         SET_GBE_FIELD(FRM_CONTROL, FRM_DMA_ENABLE, val, 1);
 363         gbe->frm_control = val;
 364         udelay(1000);
 365         for (i = 0; i < 10000; i++) {
 366                 val = gbe->frm_inhwctrl;
 367                 if (GET_GBE_FIELD(FRM_INHWCTRL, FRM_DMA_ENABLE, val) != 1)
 368                         udelay(10);
 369                 else
 370                         break;
 371         }
 372         if (i == 10000)
 373                 printk(KERN_ERR "gbefb: turn on DMA timed out\n");
 374 }
 375
 376 /*
 377  *  Blank the display.
 378  */
 379 static int gbefb_blank(int blank, struct fb_info *info)
 380 {
 381         /* 0 unblank, 1 blank, 2 no vsync, 3 no hsync, 4 off */
 382         switch (blank) {
 383         case FB_BLANK_UNBLANK:          /* unblank */
 384                 gbe_turn_on();
 385                 break;
 386
 387         case FB_BLANK_NORMAL:           /* blank */
 388                 gbe_turn_off();
 389                 break;
 390
 391         default:
 392                 /* Nothing */
 393                 break;
 394         }
 395         return 0;
 396 }
 397
 398 /*
 399  *  Setup flatpanel related registers.
 400  */
 401 static void gbefb_setup_flatpanel(struct gbe_timing_info *timing)
 402 {
 403         int fp_wid, fp_hgt, fp_vbs, fp_vbe;
 404         u32 outputVal = 0;
 405
 406         SET_GBE_FIELD(VT_FLAGS, HDRV_INVERT, outputVal,
 407                 (timing->flags & FB_SYNC_HOR_HIGH_ACT) ? 0 : 1);
 408         SET_GBE_FIELD(VT_FLAGS, VDRV_INVERT, outputVal,
 409                 (timing->flags & FB_SYNC_VERT_HIGH_ACT) ? 0 : 1);
 410         gbe->vt_flags = outputVal;
 411
 412         /* Turn on the flat panel */
 413         fp_wid = 1600;
 414         fp_hgt = 1024;
 415         fp_vbs = 0;
 416         fp_vbe = 1600;
 417         timing->pll_m = 4;
 418         timing->pll_n = 1;
 419         timing->pll_p = 0;
 420
 421         outputVal = 0;
 422         SET_GBE_FIELD(FP_DE, ON, outputVal, fp_vbs);
 423         SET_GBE_FIELD(FP_DE, OFF, outputVal, fp_vbe);
 424         gbe->fp_de = outputVal;
 425         outputVal = 0;
 426         SET_GBE_FIELD(FP_HDRV, OFF, outputVal, fp_wid);
 427         gbe->fp_hdrv = outputVal;
 428         outputVal = 0;
 429         SET_GBE_FIELD(FP_VDRV, ON, outputVal, 1);
 430         SET_GBE_FIELD(FP_VDRV, OFF, outputVal, fp_hgt + 1);
 431         gbe->fp_vdrv = outputVal;
 432 }
 433
 434 struct gbe_pll_info {
 435         int clock_rate;
 436         int fvco_min;
 437         int fvco_max;
 438 };
 439
 440 static struct gbe_pll_info gbe_pll_table[2] = {
 441         { 20, 80, 220 },
 442         { 27, 80, 220 },
 443 };
 444
 445 static int compute_gbe_timing(struct fb_var_screeninfo *var,
 446                               struct gbe_timing_info *timing)
 447 {
 448         int pll_m, pll_n, pll_p, error, best_m, best_n, best_p, best_error;
 449         int pixclock;
 450         struct gbe_pll_info *gbe_pll;
 451
 452         if (gbe_revision < 2)
 453                 gbe_pll = &gbe_pll_table[0];
 454         else
 455                 gbe_pll = &gbe_pll_table[1];
 456
 457         /* Determine valid resolution and timing
 458          * GBE crystal runs at 20Mhz or 27Mhz
 459          * pll_m, pll_n, pll_p define the following frequencies
 460          * fvco = pll_m * 20Mhz / pll_n
 461          * fout = fvco / (2**pll_p) */
 462         best_error = 1000000000;
 463         best_n = best_m = best_p = 0;
 464         for (pll_p = 0; pll_p < 4; pll_p++)
 465                 for (pll_m = 1; pll_m < 256; pll_m++)
 466                         for (pll_n = 1; pll_n < 64; pll_n++) {
 467                                 pixclock = (1000000 / gbe_pll->clock_rate) *
 468                                                 (pll_n << pll_p) / pll_m;
 469
 470                                 error = var->pixclock - pixclock;
 471
 472                                 if (error < 0)
 473                                         error = -error;
 474
 475                                 if (error < best_error &&
 476                                     pll_m / pll_n >
 477                                     gbe_pll->fvco_min / gbe_pll->clock_rate &&
 478                                     pll_m / pll_n <
 479                                     gbe_pll->fvco_max / gbe_pll->clock_rate) {
 480                                         best_error = error;
 481                                         best_m = pll_m;
 482                                         best_n = pll_n;
 483                                         best_p = pll_p;
 484                                 }
 485                         }
 486
 487         if (!best_n || !best_m)
 488                 return -EINVAL; /* Resolution to high */
 489
 490         pixclock = (1000000 / gbe_pll->clock_rate) *
 491                 (best_n << best_p) / best_m;
 492
 493         /* set video timing information */
 494         if (timing) {
 495                 timing->width = var->xres;
 496                 timing->height = var->yres;
 497                 timing->pll_m = best_m;
 498                 timing->pll_n = best_n;
 499                 timing->pll_p = best_p;
 500                 timing->cfreq = gbe_pll->clock_rate * 1000 * timing->pll_m /
 501                         (timing->pll_n << timing->pll_p);
 502                 timing->htotal = var->left_margin + var->xres +
 503                                 var->right_margin + var->hsync_len;
 504                 timing->vtotal = var->upper_margin + var->yres +
 505                                 var->lower_margin + var->vsync_len;
 506                 timing->fields_sec = 1000 * timing->cfreq / timing->htotal *
 507                                 1000 / timing->vtotal;
 508                 timing->hblank_start = var->xres;
 509                 timing->vblank_start = var->yres;
 510                 timing->hblank_end = timing->htotal;
 511                 timing->hsync_start = var->xres + var->right_margin + 1;
 512                 timing->hsync_end = timing->hsync_start + var->hsync_len;
 513                 timing->vblank_end = timing->vtotal;
 514                 timing->vsync_start = var->yres + var->lower_margin + 1;
 515                 timing->vsync_end = timing->vsync_start + var->vsync_len;
 516         }
 517
 518         return pixclock;
 519 }
 520
 521 static void gbe_set_timing_info(struct gbe_timing_info *timing)
 522 {
 523         int temp;
 524         unsigned int val;
 525
 526         /* setup dot clock PLL */
 527         val = 0;
 528         SET_GBE_FIELD(DOTCLK, M, val, timing->pll_m - 1);
 529         SET_GBE_FIELD(DOTCLK, N, val, timing->pll_n - 1);
 530         SET_GBE_FIELD(DOTCLK, P, val, timing->pll_p);
 531         SET_GBE_FIELD(DOTCLK, RUN, val, 0);     /* do not start yet */
 532         gbe->dotclock = val;
 533         udelay(10000);
 534
 535         /* setup pixel counter */
 536         val = 0;
 537         SET_GBE_FIELD(VT_XYMAX, MAXX, val, timing->htotal);
 538         SET_GBE_FIELD(VT_XYMAX, MAXY, val, timing->vtotal);
 539         gbe->vt_xymax = val;
 540
 541         /* setup video timing signals */
 542         val = 0;
 543         SET_GBE_FIELD(VT_VSYNC, VSYNC_ON, val, timing->vsync_start);
 544         SET_GBE_FIELD(VT_VSYNC, VSYNC_OFF, val, timing->vsync_end);
 545         gbe->vt_vsync = val;
 546         val = 0;
 547         SET_GBE_FIELD(VT_HSYNC, HSYNC_ON, val, timing->hsync_start);
 548         SET_GBE_FIELD(VT_HSYNC, HSYNC_OFF, val, timing->hsync_end);
 549         gbe->vt_hsync = val;
 550         val = 0;
 551         SET_GBE_FIELD(VT_VBLANK, VBLANK_ON, val, timing->vblank_start);
 552         SET_GBE_FIELD(VT_VBLANK, VBLANK_OFF, val, timing->vblank_end);
 553         gbe->vt_vblank = val;
 554         val = 0;
 555         SET_GBE_FIELD(VT_HBLANK, HBLANK_ON, val,
 556                       timing->hblank_start - 5);
 557         SET_GBE_FIELD(VT_HBLANK, HBLANK_OFF, val,
 558                       timing->hblank_end - 3);
 559         gbe->vt_hblank = val;
 560
 561         /* setup internal timing signals */
 562         val = 0;
 563         SET_GBE_FIELD(VT_VCMAP, VCMAP_ON, val, timing->vblank_start);
 564         SET_GBE_FIELD(VT_VCMAP, VCMAP_OFF, val, timing->vblank_end);
 565         gbe->vt_vcmap = val;
 566         val = 0;
 567         SET_GBE_FIELD(VT_HCMAP, HCMAP_ON, val, timing->hblank_start);
 568         SET_GBE_FIELD(VT_HCMAP, HCMAP_OFF, val, timing->hblank_end);
 569         gbe->vt_hcmap = val;
 570
 571         val = 0;
 572         temp = timing->vblank_start - timing->vblank_end - 1;
 573         if (temp > 0)
 574                 temp = -temp;
 575
 576         if (flat_panel_enabled)
 577                 gbefb_setup_flatpanel(timing);
 578
 579         SET_GBE_FIELD(DID_START_XY, DID_STARTY, val, (u32) temp);
 580         if (timing->hblank_end >= 20)
 581                 SET_GBE_FIELD(DID_START_XY, DID_STARTX, val,
 582                               timing->hblank_end - 20);
 583         else
 584                 SET_GBE_FIELD(DID_START_XY, DID_STARTX, val,
 585                               timing->htotal - (20 - timing->hblank_end));
 586         gbe->did_start_xy = val;
 587
 588         val = 0;
 589         SET_GBE_FIELD(CRS_START_XY, CRS_STARTY, val, (u32) (temp + 1));
 590         if (timing->hblank_end >= GBE_CRS_MAGIC)
 591                 SET_GBE_FIELD(CRS_START_XY, CRS_STARTX, val,
 592                               timing->hblank_end - GBE_CRS_MAGIC);
 593         else
 594                 SET_GBE_FIELD(CRS_START_XY, CRS_STARTX, val,
 595                               timing->htotal - (GBE_CRS_MAGIC -
 596                                                 timing->hblank_end));
 597         gbe->crs_start_xy = val;
 598
 599         val = 0;
 600         SET_GBE_FIELD(VC_START_XY, VC_STARTY, val, (u32) temp);
 601         SET_GBE_FIELD(VC_START_XY, VC_STARTX, val, timing->hblank_end - 4);
 602         gbe->vc_start_xy = val;
 603
 604         val = 0;
 605         temp = timing->hblank_end - GBE_PIXEN_MAGIC_ON;
 606         if (temp < 0)
 607                 temp += timing->htotal; /* allow blank to wrap around */
 608
 609         SET_GBE_FIELD(VT_HPIXEN, HPIXEN_ON, val, temp);
 610         SET_GBE_FIELD(VT_HPIXEN, HPIXEN_OFF, val,
 611                       ((temp + timing->width -
 612                         GBE_PIXEN_MAGIC_OFF) % timing->htotal));
 613         gbe->vt_hpixen = val;
 614
 615         val = 0;
 616         SET_GBE_FIELD(VT_VPIXEN, VPIXEN_ON, val, timing->vblank_end);
 617         SET_GBE_FIELD(VT_VPIXEN, VPIXEN_OFF, val, timing->vblank_start);
 618         gbe->vt_vpixen = val;
 619
 620         /* turn off sync on green */
 621         val = 0;
 622         SET_GBE_FIELD(VT_FLAGS, SYNC_LOW, val, 1);
 623         gbe->vt_flags = val;
 624 }
 625
 626 /*
 627  *  Set the hardware according to 'par'.
 628  */
 629
 630 static int gbefb_set_par(struct fb_info *info)
 631 {
 632         int i;
 633         unsigned int val;
 634         int wholeTilesX, partTilesX, maxPixelsPerTileX;
 635         int height_pix;
 636         int xpmax, ypmax;       /* Monitor resolution */
 637         int bytesPerPixel;      /* Bytes per pixel */
 638         struct gbefb_par *par = (struct gbefb_par *) info->par;
 639
 640         compute_gbe_timing(&info->var, &par->timing);
 641
 642         bytesPerPixel = info->var.bits_per_pixel / 8;
 643         info->fix.line_length = info->var.xres_virtual * bytesPerPixel;
 644         xpmax = par->timing.width;
 645         ypmax = par->timing.height;
 646
 647         /* turn off GBE */
 648         gbe_turn_off();
 649
 650         /* set timing info */
 651         gbe_set_timing_info(&par->timing);
 652
 653         /* initialize DIDs */
 654         val = 0;
 655         switch (bytesPerPixel) {
 656         case 1:
 657                 SET_GBE_FIELD(WID, TYP, val, GBE_CMODE_I8);
 658                 info->fix.visual = FB_VISUAL_PSEUDOCOLOR;
 659                 break;
 660         case 2:
 661                 SET_GBE_FIELD(WID, TYP, val, GBE_CMODE_ARGB5);
 662                 info->fix.visual = FB_VISUAL_TRUECOLOR;
 663                 break;
 664         case 4:
 665                 SET_GBE_FIELD(WID, TYP, val, GBE_CMODE_RGB8);
 666                 info->fix.visual = FB_VISUAL_TRUECOLOR;
 667                 break;
 668         }
 669         SET_GBE_FIELD(WID, BUF, val, GBE_BMODE_BOTH);
 670
 671         for (i = 0; i < 32; i++)
 672                 gbe->mode_regs[i] = val;
 673
 674         /* Initialize interrupts */
 675         gbe->vt_intr01 = 0xffffffff;
 676         gbe->vt_intr23 = 0xffffffff;
 677
 678         /* HACK:
 679            The GBE hardware uses a tiled memory to screen mapping. Tiles are
 680            blocks of 512x128, 256x128 or 128x128 pixels, respectively for 8bit,
 681            16bit and 32 bit modes (64 kB). They cover the screen with partial
 682            tiles on the right and/or bottom of the screen if needed.
 683            For exemple in 640x480 8 bit mode the mapping is:
 684
 685            <-------- 640 ----->
 686            <---- 512 ----><128|384 offscreen>
 687            ^  ^
 688            | 128    [tile 0]        [tile 1]
 689            |  v
 690            ^
 691            4 128    [tile 2]        [tile 3]
 692            8  v
 693            0  ^
 694            128    [tile 4]        [tile 5]
 695            |  v
 696            |  ^
 697            v  96    [tile 6]        [tile 7]
 698            32 offscreen
 699
 700            Tiles have the advantage that they can be allocated individually in
 701            memory. However, this mapping is not linear at all, which is not
 702            really convienient. In order to support linear addressing, the GBE
 703            DMA hardware is fooled into thinking the screen is only one tile
 704            large and but has a greater height, so that the DMA transfer covers
 705            the same region.
 706            Tiles are still allocated as independent chunks of 64KB of
 707            continuous physical memory and remapped so that the kernel sees the
 708            framebuffer as a continuous virtual memory. The GBE tile table is
 709            set up so that each tile references one of these 64k blocks:
 710
 711            GBE -> tile list    framebuffer           TLB   <------------ CPU
 712                   [ tile 0 ] -> [ 64KB ]  <- [ 16x 4KB page entries ]     ^
 713                      ...           ...              ...       linear virtual FB
 714                   [ tile n ] -> [ 64KB ]  <- [ 16x 4KB page entries ]     v
 715
 716
 717            The GBE hardware is then told that the buffer is 512*tweaked_height,
 718            with tweaked_height = real_width*real_height/pixels_per_tile.
 719            Thus the GBE hardware will scan the first tile, filing the first 64k
 720            covered region of the screen, and then will proceed to the next
 721            tile, until the whole screen is covered.
 722
 723            Here is what would happen at 640x480 8bit:
 724
 725            normal tiling               linear
 726            ^   11111111111111112222    11111111111111111111  ^
 727            128 11111111111111112222    11111111111111111111 102 lines
 728                11111111111111112222    11111111111111111111  v
 729            V   11111111111111112222    11111111222222222222
 730                33333333333333334444    22222222222222222222
 731                33333333333333334444    22222222222222222222
 732                <      512     >        <  256 >               102*640+256 = 64k
 733
 734            NOTE: The only mode for which this is not working is 800x600 8bit,
 735            as 800*600/512 = 937.5 which is not integer and thus causes
 736            flickering.
 737            I guess this is not so important as one can use 640x480 8bit or
 738            800x600 16bit anyway.
 739          */
 740
 741         /* Tell gbe about the tiles table location */
 742         /* tile_ptr -> [ tile 1 ] -> FB mem */
 743         /*             [ tile 2 ] -> FB mem */
 744         /*               ...                */
 745         val = 0;
 746         SET_GBE_FIELD(FRM_CONTROL, FRM_TILE_PTR, val, gbe_tiles.dma >> 9);
 747         SET_GBE_FIELD(FRM_CONTROL, FRM_DMA_ENABLE, val, 0); /* do not start */
 748         SET_GBE_FIELD(FRM_CONTROL, FRM_LINEAR, val, 0);
 749         gbe->frm_control = val;
 750
 751         maxPixelsPerTileX = 512 / bytesPerPixel;
 752         wholeTilesX = 1;
 753         partTilesX = 0;
 754
 755         /* Initialize the framebuffer */
 756         val = 0;
 757         SET_GBE_FIELD(FRM_SIZE_TILE, FRM_WIDTH_TILE, val, wholeTilesX);
 758         SET_GBE_FIELD(FRM_SIZE_TILE, FRM_RHS, val, partTilesX);
 759
 760         switch (bytesPerPixel) {
 761         case 1:
 762                 SET_GBE_FIELD(FRM_SIZE_TILE, FRM_DEPTH, val,
 763                               GBE_FRM_DEPTH_8);
 764                 break;
 765         case 2:
 766                 SET_GBE_FIELD(FRM_SIZE_TILE, FRM_DEPTH, val,
 767                               GBE_FRM_DEPTH_16);
 768                 break;
 769         case 4:
 770                 SET_GBE_FIELD(FRM_SIZE_TILE, FRM_DEPTH, val,
 771                               GBE_FRM_DEPTH_32);
 772                 break;
 773         }
 774         gbe->frm_size_tile = val;
 775
 776         /* compute tweaked height */
 777         height_pix = xpmax * ypmax / maxPixelsPerTileX;
 778
 779         val = 0;
 780         SET_GBE_FIELD(FRM_SIZE_PIXEL, FB_HEIGHT_PIX, val, height_pix);
 781         gbe->frm_size_pixel = val;
 782
 783         /* turn off DID and overlay DMA */
 784         gbe->did_control = 0;
 785         gbe->ovr_width_tile = 0;
 786
 787         /* Turn off mouse cursor */
 788         gbe->crs_ctl = 0;
 789
 790         /* Turn on GBE */
 791         gbe_turn_on();
 792
 793         /* Initialize the gamma map */
 794         udelay(10);
 795         for (i = 0; i < 256; i++)
 796                 gbe->gmap[i] = (i << 24) | (i << 16) | (i << 8);
 797
 798         /* Initialize the color map */
 799         for (i = 0; i < 256; i++) {
 800                 int j;
 801
 802                 for (j = 0; j < 1000 && gbe->cm_fifo >= 63; j++)
 803                         udelay(10);
 804                 if (j == 1000)
 805                         printk(KERN_ERR "gbefb: cmap FIFO timeout\n");
 806
 807                 gbe->cmap[i] = (i << 8) | (i << 16) | (i << 24);
 808         }
 809
 810         return 0;
 811 }
 812
 813 static void gbefb_encode_fix(struct fb_fix_screeninfo *fix,
 814                              struct fb_var_screeninfo *var)
 815 {
 816         memset(fix, 0, sizeof(struct fb_fix_screeninfo));
 817         strcpy(fix->id, "SGI GBE");
 818         fix->smem_start = (unsigned long) gbe_mem;
 819         fix->smem_len = gbe_mem_size;
 820         fix->type = FB_TYPE_PACKED_PIXELS;
 821         fix->type_aux = 0;
 822         fix->accel = FB_ACCEL_NONE;
 823         switch (var->bits_per_pixel) {
 824         case 8:
 825                 fix->visual = FB_VISUAL_PSEUDOCOLOR;
 826                 break;
 827         default:
 828                 fix->visual = FB_VISUAL_TRUECOLOR;
 829                 break;
 830         }
 831         fix->ywrapstep = 0;
 832         fix->xpanstep = 0;
 833         fix->ypanstep = 0;
 834         fix->line_length = var->xres_virtual * var->bits_per_pixel / 8;
 835         fix->mmio_start = GBE_BASE;
 836         fix->mmio_len = sizeof(struct sgi_gbe);
 837 }
 838
 839 /*
 840  *  Set a single color register. The values supplied are already
 841  *  rounded down to the hardware's capabilities (according to the
 842  *  entries in the var structure). Return != 0 for invalid regno.
 843  */
 844
 845 static int gbefb_setcolreg(unsigned regno, unsigned red, unsigned green,
 846                              unsigned blue, unsigned transp,
 847                              struct fb_info *info)
 848 {
 849         int i;
 850
 851         if (regno > 255)
 852                 return 1;
 853         red >>= 8;
 854         green >>= 8;
 855         blue >>= 8;
 856
 857         switch (info->var.bits_per_pixel) {
 858         case 8:
 859                 /* wait for the color map FIFO to have a free entry */
 860                 for (i = 0; i < 1000 && gbe->cm_fifo >= 63; i++)
 861                         udelay(10);
 862                 if (i == 1000) {
 863                         printk(KERN_ERR "gbefb: cmap FIFO timeout\n");
 864                         return 1;
 865                 }
 866                 gbe->cmap[regno] = (red << 24) | (green << 16) | (blue << 8);
 867                 break;
 868         case 15:
 869         case 16:
 870                 red >>= 3;
 871                 green >>= 3;
 872                 blue >>= 3;
 873                 pseudo_palette[regno] =
 874                         (red << info->var.red.offset) |
 875                         (green << info->var.green.offset) |
 876                         (blue << info->var.blue.offset);
 877                 break;
 878         case 32:
 879                 pseudo_palette[regno] =
 880                         (red << info->var.red.offset) |
 881                         (green << info->var.green.offset) |
 882                         (blue << info->var.blue.offset);
 883                 break;
 884         }
 885
 886         return 0;
 887 }
 888
 889 /*
 890  *  Check video mode validity, eventually modify var to best match.
 891  */
 892 static int gbefb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
 893 {
 894         unsigned int line_length;
 895         struct gbe_timing_info timing;
 896
 897         /* Limit bpp to 8, 16, and 32 */
 898         if (var->bits_per_pixel <= 8)
 899                 var->bits_per_pixel = 8;
 900         else if (var->bits_per_pixel <= 16)
 901                 var->bits_per_pixel = 16;
 902         else if (var->bits_per_pixel <= 32)
 903                 var->bits_per_pixel = 32;
 904         else
 905                 return -EINVAL;
 906
 907         /* Check the mode can be mapped linearly with the tile table trick. */
 908         /* This requires width x height x bytes/pixel be a multiple of 512 */
 909         if ((var->xres * var->yres * var->bits_per_pixel) & 4095)
 910                 return -EINVAL;
 911
 912         var->grayscale = 0;     /* No grayscale for now */
 913
 914         if ((var->pixclock = compute_gbe_timing(var, &timing)) < 0)
 915                 return(-EINVAL);
 916
 917         /* Adjust virtual resolution, if necessary */
 918         if (var->xres > var->xres_virtual || (!ywrap && !ypan))
 919                 var->xres_virtual = var->xres;
 920         if (var->yres > var->yres_virtual || (!ywrap && !ypan))
 921                 var->yres_virtual = var->yres;
 922
 923         if (var->vmode & FB_VMODE_CONUPDATE) {
 924                 var->vmode |= FB_VMODE_YWRAP;
 925                 var->xoffset = info->var.xoffset;
 926                 var->yoffset = info->var.yoffset;
 927         }
 928
 929         /* No grayscale for now */
 930         var->grayscale = 0;
 931
 932         /* Memory limit */
 933         line_length = var->xres_virtual * var->bits_per_pixel / 8;
 934         if (line_length * var->yres_virtual > gbe_mem_size)
 935                 return -ENOMEM; /* Virtual resolution too high */
 936
 937         switch (var->bits_per_pixel) {
 938         case 8:
 939                 var->red.offset = 0;
 940                 var->red.length = 8;
 941                 var->green.offset = 0;
 942                 var->green.length = 8;
 943                 var->blue.offset = 0;
 944                 var->blue.length = 8;
 945                 var->transp.offset = 0;
 946                 var->transp.length = 0;
 947                 break;
 948         case 16:                /* RGB 1555 */
 949                 var->red.offset = 10;
 950                 var->red.length = 5;
 951                 var->green.offset = 5;
 952                 var->green.length = 5;
 953                 var->blue.offset = 0;
 954                 var->blue.length = 5;
 955                 var->transp.offset = 0;
 956                 var->transp.length = 0;
 957                 break;
 958         case 32:                /* RGB 8888 */
 959                 var->red.offset = 24;
 960                 var->red.length = 8;
 961                 var->green.offset = 16;
 962                 var->green.length = 8;
 963                 var->blue.offset = 8;
 964                 var->blue.length = 8;
 965                 var->transp.offset = 0;
 966                 var->transp.length = 8;
 967                 break;
 968         }
 969         var->red.msb_right = 0;
 970         var->green.msb_right = 0;
 971         var->blue.msb_right = 0;
 972         var->transp.msb_right = 0;
 973
 974         var->left_margin = timing.htotal - timing.hsync_end;
 975         var->right_margin = timing.hsync_start - timing.width;
 976         var->upper_margin = timing.vtotal - timing.vsync_end;
 977         var->lower_margin = timing.vsync_start - timing.height;
 978         var->hsync_len = timing.hsync_end - timing.hsync_start;
 979         var->vsync_len = timing.vsync_end - timing.vsync_start;
 980
 981         return 0;
 982 }
 983
 984 static int gbefb_mmap(struct fb_info *info,
 985                         struct vm_area_struct *vma)
 986 {
 987         unsigned long size = vma->vm_end - vma->vm_start;
 988         unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
 989         unsigned long addr;
 990         unsigned long phys_addr, phys_size;
 991         u16 *tile;
 992
 993         /* check range */
 994         if (vma->vm_pgoff > (~0UL >> PAGE_SHIFT))
 995                 return -EINVAL;
 996         if (offset + size > gbe_mem_size)
 997                 return -EINVAL;
 998
 999         /* remap using the fastest write-through mode on architecture */
1000         /* try not polluting the cache when possible */
1001         pgprot_val(vma->vm_page_prot) =
1002                 pgprot_fb(pgprot_val(vma->vm_page_prot));
1003
1004         vma->vm_flags |= VM_IO | VM_RESERVED;
1005
1006         /* look for the starting tile */
1007         tile = &gbe_tiles.cpu[offset >> TILE_SHIFT];
1008         addr = vma->vm_start;
1009         offset &= TILE_MASK;
1010
1011         /* remap each tile separately */
1012         do {
1013                 phys_addr = (((unsigned long) (*tile)) << TILE_SHIFT) + offset;
1014                 if ((offset + size) < TILE_SIZE)
1015                         phys_size = size;
1016                 else
1017                         phys_size = TILE_SIZE - offset;
1018
1019                 if (remap_pfn_range(vma, addr, phys_addr >> PAGE_SHIFT,
1020                                                 phys_size, vma->vm_page_prot))
1021                         return -EAGAIN;
1022
1023                 offset = 0;
1024                 size -= phys_size;
1025                 addr += phys_size;
1026                 tile++;
1027         } while (size);
1028
1029         return 0;
1030 }
1031
1032 static struct fb_ops gbefb_ops = {
1033         .owner          = THIS_MODULE,
1034         .fb_check_var   = gbefb_check_var,
1035         .fb_set_par     = gbefb_set_par,
1036         .fb_setcolreg   = gbefb_setcolreg,
1037         .fb_mmap        = gbefb_mmap,
1038         .fb_blank       = gbefb_blank,
1039         .fb_fillrect    = cfb_fillrect,
1040         .fb_copyarea    = cfb_copyarea,
1041         .fb_imageblit   = cfb_imageblit,
1042 };
1043
1044 /*
1045  * sysfs
1046  */
1047
1048 static ssize_t gbefb_show_memsize(struct device *dev, struct device_attribute *attr, char *buf)
1049 {
1050         return snprintf(buf, PAGE_SIZE, "%d\n", gbe_mem_size);
1051 }
1052
1053 static DEVICE_ATTR(size, S_IRUGO, gbefb_show_memsize, NULL);
1054
1055 static ssize_t gbefb_show_rev(struct device *device, struct device_attribute *attr, char *buf)
1056 {
1057         return snprintf(buf, PAGE_SIZE, "%d\n", gbe_revision);
1058 }
1059
1060 static DEVICE_ATTR(revision, S_IRUGO, gbefb_show_rev, NULL);
1061
1062 static void __devexit gbefb_remove_sysfs(struct device *dev)
1063 {
1064         device_remove_file(dev, &dev_attr_size);
1065         device_remove_file(dev, &dev_attr_revision);
1066 }
1067
1068 static void gbefb_create_sysfs(struct device *dev)
1069 {
1070         device_create_file(dev, &dev_attr_size);
1071         device_create_file(dev, &dev_attr_revision);
1072 }
1073
1074 /*
1075  * Initialization
1076  */
1077
1078 int __init gbefb_setup(char *options)
1079 {
1080         char *this_opt;
1081
1082         if (!options || !*options)
1083                 return 0;
1084
1085         while ((this_opt = strsep(&options, ",")) != NULL) {
1086                 if (!strncmp(this_opt, "monitor:", 8)) {
1087                         if (!strncmp(this_opt + 8, "crt", 3)) {
1088                                 flat_panel_enabled = 0;
1089                                 default_var = &default_var_CRT;
1090                                 default_mode = &default_mode_CRT;
1091                         } else if (!strncmp(this_opt + 8, "1600sw", 6) ||
1092                                    !strncmp(this_opt + 8, "lcd", 3)) {
1093                                 flat_panel_enabled = 1;
1094                                 default_var = &default_var_LCD;
1095                                 default_mode = &default_mode_LCD;
1096                         }
1097                 } else if (!strncmp(this_opt, "mem:", 4)) {
1098                         gbe_mem_size = memparse(this_opt + 4, &this_opt);
1099                         if (gbe_mem_size > CONFIG_FB_GBE_MEM * 1024 * 1024)
1100                                 gbe_mem_size = CONFIG_FB_GBE_MEM * 1024 * 1024;
1101                         if (gbe_mem_size < TILE_SIZE)
1102                                 gbe_mem_size = TILE_SIZE;
1103                 } else
1104                         mode_option = this_opt;
1105         }
1106         return 0;
1107 }
1108
1109 static int __init gbefb_probe(struct platform_device *p_dev)
1110 {
1111         int i, ret = 0;
1112         struct fb_info *info;
1113         struct gbefb_par *par;
1114 #ifndef MODULE
1115         char *options = NULL;
1116 #endif
1117
1118         info = framebuffer_alloc(sizeof(struct gbefb_par), &p_dev->dev);
1119         if (!info)
1120                 return -ENOMEM;
1121
1122 #ifndef MODULE
1123         if (fb_get_options("gbefb", &options))
1124                 return -ENODEV;
1125         gbefb_setup(options);
1126 #endif
1127
1128         if (!request_region(GBE_BASE, sizeof(struct sgi_gbe), "GBE")) {
1129                 printk(KERN_ERR "gbefb: couldn't reserve mmio region\n");
1130                 ret = -EBUSY;
1131                 goto out_release_framebuffer;
1132         }
1133
1134         gbe = (struct sgi_gbe *) ioremap(GBE_BASE, sizeof(struct sgi_gbe));
1135         if (!gbe) {
1136                 printk(KERN_ERR "gbefb: couldn't map mmio region\n");
1137                 ret = -ENXIO;
1138                 goto out_release_mem_region;
1139         }
1140         gbe_revision = gbe->ctrlstat & 15;
1141
1142         gbe_tiles.cpu =
1143                 dma_alloc_coherent(NULL, GBE_TLB_SIZE * sizeof(uint16_t),
1144                                    &gbe_tiles.dma, GFP_KERNEL);
1145         if (!gbe_tiles.cpu) {
1146                 printk(KERN_ERR "gbefb: couldn't allocate tiles table\n");
1147                 ret = -ENOMEM;
1148                 goto out_unmap;
1149         }
1150
1151         if (gbe_mem_phys) {
1152                 /* memory was allocated at boot time */
1153                 gbe_mem = ioremap_nocache(gbe_mem_phys, gbe_mem_size);
1154                 if (!gbe_mem) {
1155                         printk(KERN_ERR "gbefb: couldn't map framebuffer\n");
1156                         ret = -ENOMEM;
1157                         goto out_tiles_free;
1158                 }
1159
1160                 gbe_dma_addr = 0;
1161         } else {
1162                 /* try to allocate memory with the classical allocator
1163                  * this has high chance to fail on low memory machines */
1164                 gbe_mem = dma_alloc_coherent(NULL, gbe_mem_size, &gbe_dma_addr,
1165                                              GFP_KERNEL);
1166                 if (!gbe_mem) {
1167                         printk(KERN_ERR "gbefb: couldn't allocate framebuffer memory\n");
1168                         ret = -ENOMEM;
1169                         goto out_tiles_free;
1170                 }
1171
1172                 gbe_mem_phys = (unsigned long) gbe_dma_addr;
1173         }
1174
1175 #ifdef CONFIG_X86
1176         mtrr_add(gbe_mem_phys, gbe_mem_size, MTRR_TYPE_WRCOMB, 1);
1177 #endif
1178
1179         /* map framebuffer memory into tiles table */
1180         for (i = 0; i < (gbe_mem_size >> TILE_SHIFT); i++)
1181                 gbe_tiles.cpu[i] = (gbe_mem_phys >> TILE_SHIFT) + i;
1182
1183         info->fbops = &gbefb_ops;
1184         info->pseudo_palette = pseudo_palette;
1185         info->flags = FBINFO_DEFAULT;
1186         info->screen_base = gbe_mem;
1187         fb_alloc_cmap(&info->cmap, 256, 0);
1188
1189         /* reset GBE */
1190         gbe_reset();
1191
1192         par = info->par;
1193         /* turn on default video mode */
1194         if (fb_find_mode(&par->var, info, mode_option, NULL, 0,
1195                          default_mode, 8) == 0)
1196                 par->var = *default_var;
1197         info->var = par->var;
1198         gbefb_check_var(&par->var, info);
1199         gbefb_encode_fix(&info->fix, &info->var);
1200
1201         if (register_framebuffer(info) < 0) {
1202                 printk(KERN_ERR "gbefb: couldn't register framebuffer\n");
1203                 ret = -ENXIO;
1204                 goto out_gbe_unmap;
1205         }
1206
1207         platform_set_drvdata(p_dev, info);
1208         gbefb_create_sysfs(&p_dev->dev);
1209
1210         printk(KERN_INFO "fb%d: %s rev %d @ 0x%08x using %dkB memory\n",
1211                info->node, info->fix.id, gbe_revision, (unsigned) GBE_BASE,
1212                gbe_mem_size >> 10);
1213
1214         return 0;
1215
1216 out_gbe_unmap:
1217         if (gbe_dma_addr)
1218                 dma_free_coherent(NULL, gbe_mem_size, gbe_mem, gbe_mem_phys);
1219         else
1220                 iounmap(gbe_mem);
1221 out_tiles_free:
1222         dma_free_coherent(NULL, GBE_TLB_SIZE * sizeof(uint16_t),
1223                           (void *)gbe_tiles.cpu, gbe_tiles.dma);
1224 out_unmap:
1225         iounmap(gbe);
1226 out_release_mem_region:
1227         release_mem_region(GBE_BASE, sizeof(struct sgi_gbe));
1228 out_release_framebuffer:
1229         framebuffer_release(info);
1230
1231         return ret;
1232 }
1233
1234 static int __devexit gbefb_remove(struct platform_device* p_dev)
1235 {
1236         struct fb_info *info = platform_get_drvdata(p_dev);
1237
1238         unregister_framebuffer(info);
1239         gbe_turn_off();
1240         if (gbe_dma_addr)
1241                 dma_free_coherent(NULL, gbe_mem_size, gbe_mem, gbe_mem_phys);
1242         else
1243                 iounmap(gbe_mem);
1244         dma_free_coherent(NULL, GBE_TLB_SIZE * sizeof(uint16_t),
1245                           (void *)gbe_tiles.cpu, gbe_tiles.dma);
1246         release_mem_region(GBE_BASE, sizeof(struct sgi_gbe));
1247         iounmap(gbe);
1248         gbefb_remove_sysfs(&p_dev->dev);
1249         framebuffer_release(info);
1250
1251         return 0;
1252 }
1253
1254 static struct platform_driver gbefb_driver = {
1255         .probe = gbefb_probe,
1256         .remove = __devexit_p(gbefb_remove),
1257         .driver = {
1258                 .name = "gbefb",
1259         },
1260 };
1261
1262 static struct platform_device *gbefb_device;
1263
1264 int __init gbefb_init(void)
1265 {
1266         int ret = platform_driver_register(&gbefb_driver);
1267         if (!ret) {
1268                 gbefb_device = platform_device_alloc("gbefb", 0);
1269                 if (gbefb_device) {
1270                         ret = platform_device_add(gbefb_device);
1271                 } else {
1272                         ret = -ENOMEM;
1273                 }
1274                 if (ret) {
1275                         platform_device_put(gbefb_device);
1276                         platform_driver_unregister(&gbefb_driver);
1277                 }
1278         }
1279         return ret;
1280 }
1281
1282 void __exit gbefb_exit(void)
1283 {
1284         platform_device_unregister(gbefb_device);
1285         platform_driver_unregister(&gbefb_driver);
1286 }
1287
1288 module_init(gbefb_init);
1289 module_exit(gbefb_exit);
1290
1291 MODULE_LICENSE("GPL");