drivers/video/tgafb.c

   1 /*
   2  *  linux/drivers/video/tgafb.c -- DEC 21030 TGA frame buffer device
   3  *
   4  *      Copyright (C) 1995 Jay Estabrook
   5  *      Copyright (C) 1997 Geert Uytterhoeven
   6  *      Copyright (C) 1999,2000 Martin Lucina, Tom Zerucha
   7  *      Copyright (C) 2002 Richard Henderson
   8  *      Copyright (C) 2006, 2007  Maciej W. Rozycki
   9  *
  10  *  This file is subject to the terms and conditions of the GNU General Public
  11  *  License. See the file COPYING in the main directory of this archive for
  12  *  more details.
  13  */
  14
  15 #include <linux/bitrev.h>
  16 #include <linux/compiler.h>
  17 #include <linux/delay.h>
  18 #include <linux/device.h>
  19 #include <linux/errno.h>
  20 #include <linux/fb.h>
  21 #include <linux/init.h>
  22 #include <linux/ioport.h>
  23 #include <linux/kernel.h>
  24 #include <linux/mm.h>
  25 #include <linux/module.h>
  26 #include <linux/pci.h>
  27 #include <linux/selection.h>
  28 #include <linux/string.h>
  29 #include <linux/tc.h>
  30
  31 #include <asm/io.h>
  32
  33 #include <video/tgafb.h>
  34
  35 #ifdef CONFIG_PCI
  36 #define TGA_BUS_PCI(dev) (dev->bus == &pci_bus_type)
  37 #else
  38 #define TGA_BUS_PCI(dev) 0
  39 #endif
  40
  41 #ifdef CONFIG_TC
  42 #define TGA_BUS_TC(dev) (dev->bus == &tc_bus_type)
  43 #else
  44 #define TGA_BUS_TC(dev) 0
  45 #endif
  46
  47 /*
  48  * Local functions.
  49  */
  50
  51 static int tgafb_check_var(struct fb_var_screeninfo *, struct fb_info *);
  52 static int tgafb_set_par(struct fb_info *);
  53 static void tgafb_set_pll(struct tga_par *, int);
  54 static int tgafb_setcolreg(unsigned, unsigned, unsigned, unsigned,
  55                            unsigned, struct fb_info *);
  56 static int tgafb_blank(int, struct fb_info *);
  57 static void tgafb_init_fix(struct fb_info *);
  58
  59 static void tgafb_imageblit(struct fb_info *, const struct fb_image *);
  60 static void tgafb_fillrect(struct fb_info *, const struct fb_fillrect *);
  61 static void tgafb_copyarea(struct fb_info *, const struct fb_copyarea *);
  62 static int tgafb_pan_display(struct fb_var_screeninfo *var, struct fb_info *info);
  63
  64 static int tgafb_register(struct device *dev);
  65 static void tgafb_unregister(struct device *dev);
  66
  67 static const char *mode_option;
  68 static const char *mode_option_pci = "640x480@60";
  69 static const char *mode_option_tc = "1280x1024@72";
  70
  71
  72 static struct pci_driver tgafb_pci_driver;
  73 static struct tc_driver tgafb_tc_driver;
  74
  75 /*
  76  *  Frame buffer operations
  77  */
  78
  79 static struct fb_ops tgafb_ops = {
  80         .owner                  = THIS_MODULE,
  81         .fb_check_var           = tgafb_check_var,
  82         .fb_set_par             = tgafb_set_par,
  83         .fb_setcolreg           = tgafb_setcolreg,
  84         .fb_blank               = tgafb_blank,
  85         .fb_pan_display         = tgafb_pan_display,
  86         .fb_fillrect            = tgafb_fillrect,
  87         .fb_copyarea            = tgafb_copyarea,
  88         .fb_imageblit           = tgafb_imageblit,
  89 };
  90
  91
  92 #ifdef CONFIG_PCI
  93 /*
  94  *  PCI registration operations
  95  */
  96 static int tgafb_pci_register(struct pci_dev *, const struct pci_device_id *);
  97 static void tgafb_pci_unregister(struct pci_dev *);
  98
  99 static struct pci_device_id const tgafb_pci_table[] = {
 100         { PCI_DEVICE(PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_TGA) },
 101         { }
 102 };
 103 MODULE_DEVICE_TABLE(pci, tgafb_pci_table);
 104
 105 static struct pci_driver tgafb_pci_driver = {
 106         .name                   = "tgafb",
 107         .id_table               = tgafb_pci_table,
 108         .probe                  = tgafb_pci_register,
 109         .remove                 = tgafb_pci_unregister,
 110 };
 111
 112 static int tgafb_pci_register(struct pci_dev *pdev,
 113                               const struct pci_device_id *ent)
 114 {
 115         return tgafb_register(&pdev->dev);
 116 }
 117
 118 static void tgafb_pci_unregister(struct pci_dev *pdev)
 119 {
 120         tgafb_unregister(&pdev->dev);
 121 }
 122 #endif /* CONFIG_PCI */
 123
 124 #ifdef CONFIG_TC
 125 /*
 126  *  TC registration operations
 127  */
 128 static int tgafb_tc_register(struct device *);
 129 static int tgafb_tc_unregister(struct device *);
 130
 131 static struct tc_device_id const tgafb_tc_table[] = {
 132         { "DEC     ", "PMAGD-AA" },
 133         { "DEC     ", "PMAGD   " },
 134         { }
 135 };
 136 MODULE_DEVICE_TABLE(tc, tgafb_tc_table);
 137
 138 static struct tc_driver tgafb_tc_driver = {
 139         .id_table               = tgafb_tc_table,
 140         .driver                 = {
 141                 .name           = "tgafb",
 142                 .bus            = &tc_bus_type,
 143                 .probe          = tgafb_tc_register,
 144                 .remove         = tgafb_tc_unregister,
 145         },
 146 };
 147
 148 static int tgafb_tc_register(struct device *dev)
 149 {
 150         int status = tgafb_register(dev);
 151         if (!status)
 152                 get_device(dev);
 153         return status;
 154 }
 155
 156 static int tgafb_tc_unregister(struct device *dev)
 157 {
 158         put_device(dev);
 159         tgafb_unregister(dev);
 160         return 0;
 161 }
 162 #endif /* CONFIG_TC */
 163
 164
 165 /**
 166  *      tgafb_check_var - Optional function.  Validates a var passed in.
 167  *      @var: frame buffer variable screen structure
 168  *      @info: frame buffer structure that represents a single frame buffer
 169  */
 170 static int
 171 tgafb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
 172 {
 173         struct tga_par *par = (struct tga_par *)info->par;
 174
 175         if (par->tga_type == TGA_TYPE_8PLANE) {
 176                 if (var->bits_per_pixel != 8)
 177                         return -EINVAL;
 178         } else {
 179                 if (var->bits_per_pixel != 32)
 180                         return -EINVAL;
 181         }
 182         var->red.length = var->green.length = var->blue.length = 8;
 183         if (var->bits_per_pixel == 32) {
 184                 var->red.offset = 16;
 185                 var->green.offset = 8;
 186                 var->blue.offset = 0;
 187         }
 188
 189         if (var->xres_virtual != var->xres || var->yres_virtual != var->yres)
 190                 return -EINVAL;
 191         if (var->nonstd)
 192                 return -EINVAL;
 193         if (1000000000 / var->pixclock > TGA_PLL_MAX_FREQ)
 194                 return -EINVAL;
 195         if ((var->vmode & FB_VMODE_MASK) != FB_VMODE_NONINTERLACED)
 196                 return -EINVAL;
 197
 198         /* Some of the acceleration routines assume the line width is
 199            a multiple of 64 bytes.  */
 200         if (var->xres * (par->tga_type == TGA_TYPE_8PLANE ? 1 : 4) % 64)
 201                 return -EINVAL;
 202
 203         return 0;
 204 }
 205
 206 /**
 207  *      tgafb_set_par - Optional function.  Alters the hardware state.
 208  *      @info: frame buffer structure that represents a single frame buffer
 209  */
 210 static int
 211 tgafb_set_par(struct fb_info *info)
 212 {
 213         static unsigned int const deep_presets[4] = {
 214                 0x00004000,
 215                 0x0000440d,
 216                 0xffffffff,
 217                 0x0000441d
 218         };
 219         static unsigned int const rasterop_presets[4] = {
 220                 0x00000003,
 221                 0x00000303,
 222                 0xffffffff,
 223                 0x00000303
 224         };
 225         static unsigned int const mode_presets[4] = {
 226                 0x00000000,
 227                 0x00000300,
 228                 0xffffffff,
 229                 0x00000300
 230         };
 231         static unsigned int const base_addr_presets[4] = {
 232                 0x00000000,
 233                 0x00000001,
 234                 0xffffffff,
 235                 0x00000001
 236         };
 237
 238         struct tga_par *par = (struct tga_par *) info->par;
 239         int tga_bus_pci = TGA_BUS_PCI(par->dev);
 240         int tga_bus_tc = TGA_BUS_TC(par->dev);
 241         u32 htimings, vtimings, pll_freq;
 242         u8 tga_type;
 243         int i;
 244
 245         /* Encode video timings.  */
 246         htimings = (((info->var.xres/4) & TGA_HORIZ_ACT_LSB)
 247                     | (((info->var.xres/4) & 0x600 << 19) & TGA_HORIZ_ACT_MSB));
 248         vtimings = (info->var.yres & TGA_VERT_ACTIVE);
 249         htimings |= ((info->var.right_margin/4) << 9) & TGA_HORIZ_FP;
 250         vtimings |= (info->var.lower_margin << 11) & TGA_VERT_FP;
 251         htimings |= ((info->var.hsync_len/4) << 14) & TGA_HORIZ_SYNC;
 252         vtimings |= (info->var.vsync_len << 16) & TGA_VERT_SYNC;
 253         htimings |= ((info->var.left_margin/4) << 21) & TGA_HORIZ_BP;
 254         vtimings |= (info->var.upper_margin << 22) & TGA_VERT_BP;
 255
 256         if (info->var.sync & FB_SYNC_HOR_HIGH_ACT)
 257                 htimings |= TGA_HORIZ_POLARITY;
 258         if (info->var.sync & FB_SYNC_VERT_HIGH_ACT)
 259                 vtimings |= TGA_VERT_POLARITY;
 260
 261         par->htimings = htimings;
 262         par->vtimings = vtimings;
 263
 264         par->sync_on_green = !!(info->var.sync & FB_SYNC_ON_GREEN);
 265
 266         /* Store other useful values in par.  */
 267         par->xres = info->var.xres;
 268         par->yres = info->var.yres;
 269         par->pll_freq = pll_freq = 1000000000 / info->var.pixclock;
 270         par->bits_per_pixel = info->var.bits_per_pixel;
 271
 272         tga_type = par->tga_type;
 273
 274         /* First, disable video.  */
 275         TGA_WRITE_REG(par, TGA_VALID_VIDEO | TGA_VALID_BLANK, TGA_VALID_REG);
 276
 277         /* Write the DEEP register.  */
 278         while (TGA_READ_REG(par, TGA_CMD_STAT_REG) & 1) /* wait for not busy */
 279                 continue;
 280         mb();
 281         TGA_WRITE_REG(par, deep_presets[tga_type] |
 282                            (par->sync_on_green ? 0x0 : 0x00010000),
 283                       TGA_DEEP_REG);
 284         while (TGA_READ_REG(par, TGA_CMD_STAT_REG) & 1) /* wait for not busy */
 285                 continue;
 286         mb();
 287
 288         /* Write some more registers.  */
 289         TGA_WRITE_REG(par, rasterop_presets[tga_type], TGA_RASTEROP_REG);
 290         TGA_WRITE_REG(par, mode_presets[tga_type], TGA_MODE_REG);
 291         TGA_WRITE_REG(par, base_addr_presets[tga_type], TGA_BASE_ADDR_REG);
 292
 293         /* Calculate & write the PLL.  */
 294         tgafb_set_pll(par, pll_freq);
 295
 296         /* Write some more registers.  */
 297         TGA_WRITE_REG(par, 0xffffffff, TGA_PLANEMASK_REG);
 298         TGA_WRITE_REG(par, 0xffffffff, TGA_PIXELMASK_REG);
 299
 300         /* Init video timing regs.  */
 301         TGA_WRITE_REG(par, htimings, TGA_HORIZ_REG);
 302         TGA_WRITE_REG(par, vtimings, TGA_VERT_REG);
 303
 304         /* Initialise RAMDAC. */
 305         if (tga_type == TGA_TYPE_8PLANE && tga_bus_pci) {
 306
 307                 /* Init BT485 RAMDAC registers.  */
 308                 BT485_WRITE(par, 0xa2 | (par->sync_on_green ? 0x8 : 0x0),
 309                             BT485_CMD_0);
 310                 BT485_WRITE(par, 0x01, BT485_ADDR_PAL_WRITE);
 311                 BT485_WRITE(par, 0x14, BT485_CMD_3); /* cursor 64x64 */
 312                 BT485_WRITE(par, 0x40, BT485_CMD_1);
 313                 BT485_WRITE(par, 0x20, BT485_CMD_2); /* cursor off, for now */
 314                 BT485_WRITE(par, 0xff, BT485_PIXEL_MASK);
 315
 316                 /* Fill palette registers.  */
 317                 BT485_WRITE(par, 0x00, BT485_ADDR_PAL_WRITE);
 318                 TGA_WRITE_REG(par, BT485_DATA_PAL, TGA_RAMDAC_SETUP_REG);
 319
 320                 for (i = 0; i < 256 * 3; i += 4) {
 321                         TGA_WRITE_REG(par, 0x55 | (BT485_DATA_PAL << 8),
 322                                       TGA_RAMDAC_REG);
 323                         TGA_WRITE_REG(par, 0x00 | (BT485_DATA_PAL << 8),
 324                                       TGA_RAMDAC_REG);
 325                         TGA_WRITE_REG(par, 0x00 | (BT485_DATA_PAL << 8),
 326                                       TGA_RAMDAC_REG);
 327                         TGA_WRITE_REG(par, 0x00 | (BT485_DATA_PAL << 8),
 328                                       TGA_RAMDAC_REG);
 329                 }
 330
 331         } else if (tga_type == TGA_TYPE_8PLANE && tga_bus_tc) {
 332
 333                 /* Init BT459 RAMDAC registers.  */
 334                 BT459_WRITE(par, BT459_REG_ACC, BT459_CMD_REG_0, 0x40);
 335                 BT459_WRITE(par, BT459_REG_ACC, BT459_CMD_REG_1, 0x00);
 336                 BT459_WRITE(par, BT459_REG_ACC, BT459_CMD_REG_2,
 337                             (par->sync_on_green ? 0xc0 : 0x40));
 338
 339                 BT459_WRITE(par, BT459_REG_ACC, BT459_CUR_CMD_REG, 0x00);
 340
 341                 /* Fill the palette.  */
 342                 BT459_LOAD_ADDR(par, 0x0000);
 343                 TGA_WRITE_REG(par, BT459_PALETTE << 2, TGA_RAMDAC_SETUP_REG);
 344
 345                 for (i = 0; i < 256 * 3; i += 4) {
 346                         TGA_WRITE_REG(par, 0x55, TGA_RAMDAC_REG);
 347                         TGA_WRITE_REG(par, 0x00, TGA_RAMDAC_REG);
 348                         TGA_WRITE_REG(par, 0x00, TGA_RAMDAC_REG);
 349                         TGA_WRITE_REG(par, 0x00, TGA_RAMDAC_REG);
 350                 }
 351
 352         } else { /* 24-plane or 24plusZ */
 353
 354                 /* Init BT463 RAMDAC registers.  */
 355                 BT463_WRITE(par, BT463_REG_ACC, BT463_CMD_REG_0, 0x40);
 356                 BT463_WRITE(par, BT463_REG_ACC, BT463_CMD_REG_1, 0x08);
 357                 BT463_WRITE(par, BT463_REG_ACC, BT463_CMD_REG_2,
 358                             (par->sync_on_green ? 0xc0 : 0x40));
 359
 360                 BT463_WRITE(par, BT463_REG_ACC, BT463_READ_MASK_0, 0xff);
 361                 BT463_WRITE(par, BT463_REG_ACC, BT463_READ_MASK_1, 0xff);
 362                 BT463_WRITE(par, BT463_REG_ACC, BT463_READ_MASK_2, 0xff);
 363                 BT463_WRITE(par, BT463_REG_ACC, BT463_READ_MASK_3, 0x0f);
 364
 365                 BT463_WRITE(par, BT463_REG_ACC, BT463_BLINK_MASK_0, 0x00);
 366                 BT463_WRITE(par, BT463_REG_ACC, BT463_BLINK_MASK_1, 0x00);
 367                 BT463_WRITE(par, BT463_REG_ACC, BT463_BLINK_MASK_2, 0x00);
 368                 BT463_WRITE(par, BT463_REG_ACC, BT463_BLINK_MASK_3, 0x00);
 369
 370                 /* Fill the palette.  */
 371                 BT463_LOAD_ADDR(par, 0x0000);
 372                 TGA_WRITE_REG(par, BT463_PALETTE << 2, TGA_RAMDAC_SETUP_REG);
 373
 374 #ifdef CONFIG_HW_CONSOLE
 375                 for (i = 0; i < 16; i++) {
 376                         int j = color_table[i];
 377
 378                         TGA_WRITE_REG(par, default_red[j], TGA_RAMDAC_REG);
 379                         TGA_WRITE_REG(par, default_grn[j], TGA_RAMDAC_REG);
 380                         TGA_WRITE_REG(par, default_blu[j], TGA_RAMDAC_REG);
 381                 }
 382                 for (i = 0; i < 512 * 3; i += 4) {
 383 #else
 384                 for (i = 0; i < 528 * 3; i += 4) {
 385 #endif
 386                         TGA_WRITE_REG(par, 0x55, TGA_RAMDAC_REG);
 387                         TGA_WRITE_REG(par, 0x00, TGA_RAMDAC_REG);
 388                         TGA_WRITE_REG(par, 0x00, TGA_RAMDAC_REG);
 389                         TGA_WRITE_REG(par, 0x00, TGA_RAMDAC_REG);
 390                 }
 391
 392                 /* Fill window type table after start of vertical retrace.  */
 393                 while (!(TGA_READ_REG(par, TGA_INTR_STAT_REG) & 0x01))
 394                         continue;
 395                 TGA_WRITE_REG(par, 0x01, TGA_INTR_STAT_REG);
 396                 mb();
 397                 while (!(TGA_READ_REG(par, TGA_INTR_STAT_REG) & 0x01))
 398                         continue;
 399                 TGA_WRITE_REG(par, 0x01, TGA_INTR_STAT_REG);
 400
 401                 BT463_LOAD_ADDR(par, BT463_WINDOW_TYPE_BASE);
 402                 TGA_WRITE_REG(par, BT463_REG_ACC << 2, TGA_RAMDAC_SETUP_REG);
 403
 404                 for (i = 0; i < 16; i++) {
 405                         TGA_WRITE_REG(par, 0x00, TGA_RAMDAC_REG);
 406                         TGA_WRITE_REG(par, 0x01, TGA_RAMDAC_REG);
 407                         TGA_WRITE_REG(par, 0x00, TGA_RAMDAC_REG);
 408                 }
 409
 410         }
 411
 412         /* Finally, enable video scan (and pray for the monitor... :-) */
 413         TGA_WRITE_REG(par, TGA_VALID_VIDEO, TGA_VALID_REG);
 414
 415         return 0;
 416 }
 417
 418 #define DIFFCHECK(X)                                                      \
 419 do {                                                                      \
 420         if (m <= 0x3f) {                                                  \
 421                 int delta = f - (TGA_PLL_BASE_FREQ * (X)) / (r << shift); \
 422                 if (delta < 0)                                            \
 423                         delta = -delta;                                   \
 424                 if (delta < min_diff)                                     \
 425                         min_diff = delta, vm = m, va = a, vr = r;         \
 426         }                                                                 \
 427 } while (0)
 428
 429 static void
 430 tgafb_set_pll(struct tga_par *par, int f)
 431 {
 432         int n, shift, base, min_diff, target;
 433         int r,a,m,vm = 34, va = 1, vr = 30;
 434
 435         for (r = 0 ; r < 12 ; r++)
 436                 TGA_WRITE_REG(par, !r, TGA_CLOCK_REG);
 437
 438         if (f > TGA_PLL_MAX_FREQ)
 439                 f = TGA_PLL_MAX_FREQ;
 440
 441         if (f >= TGA_PLL_MAX_FREQ / 2)
 442                 shift = 0;
 443         else if (f >= TGA_PLL_MAX_FREQ / 4)
 444                 shift = 1;
 445         else
 446                 shift = 2;
 447
 448         TGA_WRITE_REG(par, shift & 1, TGA_CLOCK_REG);
 449         TGA_WRITE_REG(par, shift >> 1, TGA_CLOCK_REG);
 450
 451         for (r = 0 ; r < 10 ; r++)
 452                 TGA_WRITE_REG(par, 0, TGA_CLOCK_REG);
 453
 454         if (f <= 120000) {
 455                 TGA_WRITE_REG(par, 0, TGA_CLOCK_REG);
 456                 TGA_WRITE_REG(par, 0, TGA_CLOCK_REG);
 457         }
 458         else if (f <= 200000) {
 459                 TGA_WRITE_REG(par, 1, TGA_CLOCK_REG);
 460                 TGA_WRITE_REG(par, 0, TGA_CLOCK_REG);
 461         }
 462         else {
 463                 TGA_WRITE_REG(par, 0, TGA_CLOCK_REG);
 464                 TGA_WRITE_REG(par, 1, TGA_CLOCK_REG);
 465         }
 466
 467         TGA_WRITE_REG(par, 1, TGA_CLOCK_REG);
 468         TGA_WRITE_REG(par, 0, TGA_CLOCK_REG);
 469         TGA_WRITE_REG(par, 0, TGA_CLOCK_REG);
 470         TGA_WRITE_REG(par, 1, TGA_CLOCK_REG);
 471         TGA_WRITE_REG(par, 0, TGA_CLOCK_REG);
 472         TGA_WRITE_REG(par, 1, TGA_CLOCK_REG);
 473
 474         target = (f << shift) / TGA_PLL_BASE_FREQ;
 475         min_diff = TGA_PLL_MAX_FREQ;
 476
 477         r = 7 / target;
 478         if (!r) r = 1;
 479
 480         base = target * r;
 481         while (base < 449) {
 482                 for (n = base < 7 ? 7 : base; n < base + target && n < 449; n++) {
 483                         m = ((n + 3) / 7) - 1;
 484                         a = 0;
 485                         DIFFCHECK((m + 1) * 7);
 486                         m++;
 487                         DIFFCHECK((m + 1) * 7);
 488                         m = (n / 6) - 1;
 489                         if ((a = n % 6))
 490                                 DIFFCHECK(n);
 491                 }
 492                 r++;
 493                 base += target;
 494         }
 495
 496         vr--;
 497
 498         for (r = 0; r < 8; r++)
 499                 TGA_WRITE_REG(par, (vm >> r) & 1, TGA_CLOCK_REG);
 500         for (r = 0; r < 8 ; r++)
 501                 TGA_WRITE_REG(par, (va >> r) & 1, TGA_CLOCK_REG);
 502         for (r = 0; r < 7 ; r++)
 503                 TGA_WRITE_REG(par, (vr >> r) & 1, TGA_CLOCK_REG);
 504         TGA_WRITE_REG(par, ((vr >> 7) & 1)|2, TGA_CLOCK_REG);
 505 }
 506
 507
 508 /**
 509  *      tgafb_setcolreg - Optional function. Sets a color register.
 510  *      @regno: boolean, 0 copy local, 1 get_user() function
 511  *      @red: frame buffer colormap structure
 512  *      @green: The green value which can be up to 16 bits wide
 513  *      @blue:  The blue value which can be up to 16 bits wide.
 514  *      @transp: If supported the alpha value which can be up to 16 bits wide.
 515  *      @info: frame buffer info structure
 516  */
 517 static int
 518 tgafb_setcolreg(unsigned regno, unsigned red, unsigned green, unsigned blue,
 519                 unsigned transp, struct fb_info *info)
 520 {
 521         struct tga_par *par = (struct tga_par *) info->par;
 522         int tga_bus_pci = TGA_BUS_PCI(par->dev);
 523         int tga_bus_tc = TGA_BUS_TC(par->dev);
 524
 525         if (regno > 255)
 526                 return 1;
 527         red >>= 8;
 528         green >>= 8;
 529         blue >>= 8;
 530
 531         if (par->tga_type == TGA_TYPE_8PLANE && tga_bus_pci) {
 532                 BT485_WRITE(par, regno, BT485_ADDR_PAL_WRITE);
 533                 TGA_WRITE_REG(par, BT485_DATA_PAL, TGA_RAMDAC_SETUP_REG);
 534                 TGA_WRITE_REG(par, red|(BT485_DATA_PAL<<8),TGA_RAMDAC_REG);
 535                 TGA_WRITE_REG(par, green|(BT485_DATA_PAL<<8),TGA_RAMDAC_REG);
 536                 TGA_WRITE_REG(par, blue|(BT485_DATA_PAL<<8),TGA_RAMDAC_REG);
 537         } else if (par->tga_type == TGA_TYPE_8PLANE && tga_bus_tc) {
 538                 BT459_LOAD_ADDR(par, regno);
 539                 TGA_WRITE_REG(par, BT459_PALETTE << 2, TGA_RAMDAC_SETUP_REG);
 540                 TGA_WRITE_REG(par, red, TGA_RAMDAC_REG);
 541                 TGA_WRITE_REG(par, green, TGA_RAMDAC_REG);
 542                 TGA_WRITE_REG(par, blue, TGA_RAMDAC_REG);
 543         } else {
 544                 if (regno < 16) {
 545                         u32 value = (regno << 16) | (regno << 8) | regno;
 546                         ((u32 *)info->pseudo_palette)[regno] = value;
 547                 }
 548                 BT463_LOAD_ADDR(par, regno);
 549                 TGA_WRITE_REG(par, BT463_PALETTE << 2, TGA_RAMDAC_SETUP_REG);
 550                 TGA_WRITE_REG(par, red, TGA_RAMDAC_REG);
 551                 TGA_WRITE_REG(par, green, TGA_RAMDAC_REG);
 552                 TGA_WRITE_REG(par, blue, TGA_RAMDAC_REG);
 553         }
 554
 555         return 0;
 556 }
 557
 558
 559 /**
 560  *      tgafb_blank - Optional function.  Blanks the display.
 561  *      @blank_mode: the blank mode we want.
 562  *      @info: frame buffer structure that represents a single frame buffer
 563  */
 564 static int
 565 tgafb_blank(int blank, struct fb_info *info)
 566 {
 567         struct tga_par *par = (struct tga_par *) info->par;
 568         u32 vhcr, vvcr, vvvr;
 569         unsigned long flags;
 570
 571         local_irq_save(flags);
 572
 573         vhcr = TGA_READ_REG(par, TGA_HORIZ_REG);
 574         vvcr = TGA_READ_REG(par, TGA_VERT_REG);
 575         vvvr = TGA_READ_REG(par, TGA_VALID_REG);
 576         vvvr &= ~(TGA_VALID_VIDEO | TGA_VALID_BLANK);
 577
 578         switch (blank) {
 579         case FB_BLANK_UNBLANK: /* Unblanking */
 580                 if (par->vesa_blanked) {
 581                         TGA_WRITE_REG(par, vhcr & 0xbfffffff, TGA_HORIZ_REG);
 582                         TGA_WRITE_REG(par, vvcr & 0xbfffffff, TGA_VERT_REG);
 583                         par->vesa_blanked = 0;
 584                 }
 585                 TGA_WRITE_REG(par, vvvr | TGA_VALID_VIDEO, TGA_VALID_REG);
 586                 break;
 587
 588         case FB_BLANK_NORMAL: /* Normal blanking */
 589                 TGA_WRITE_REG(par, vvvr | TGA_VALID_VIDEO | TGA_VALID_BLANK,
 590                               TGA_VALID_REG);
 591                 break;
 592
 593         case FB_BLANK_VSYNC_SUSPEND: /* VESA blank (vsync off) */
 594                 TGA_WRITE_REG(par, vvcr | 0x40000000, TGA_VERT_REG);
 595                 TGA_WRITE_REG(par, vvvr | TGA_VALID_BLANK, TGA_VALID_REG);
 596                 par->vesa_blanked = 1;
 597                 break;
 598
 599         case FB_BLANK_HSYNC_SUSPEND: /* VESA blank (hsync off) */
 600                 TGA_WRITE_REG(par, vhcr | 0x40000000, TGA_HORIZ_REG);
 601                 TGA_WRITE_REG(par, vvvr | TGA_VALID_BLANK, TGA_VALID_REG);
 602                 par->vesa_blanked = 1;
 603                 break;
 604
 605         case FB_BLANK_POWERDOWN: /* Poweroff */
 606                 TGA_WRITE_REG(par, vhcr | 0x40000000, TGA_HORIZ_REG);
 607                 TGA_WRITE_REG(par, vvcr | 0x40000000, TGA_VERT_REG);
 608                 TGA_WRITE_REG(par, vvvr | TGA_VALID_BLANK, TGA_VALID_REG);
 609                 par->vesa_blanked = 1;
 610                 break;
 611         }
 612
 613         local_irq_restore(flags);
 614         return 0;
 615 }
 616
 617
 618 /*
 619  *  Acceleration.
 620  */
 621
 622 static void
 623 tgafb_mono_imageblit(struct fb_info *info, const struct fb_image *image)
 624 {
 625         struct tga_par *par = (struct tga_par *) info->par;
 626         u32 fgcolor, bgcolor, dx, dy, width, height, vxres, vyres, pixelmask;
 627         unsigned long rincr, line_length, shift, pos, is8bpp;
 628         unsigned long i, j;
 629         const unsigned char *data;
 630         void __iomem *regs_base;
 631         void __iomem *fb_base;
 632
 633         is8bpp = info->var.bits_per_pixel == 8;
 634
 635         dx = image->dx;
 636         dy = image->dy;
 637         width = image->width;
 638         height = image->height;
 639         vxres = info->var.xres_virtual;
 640         vyres = info->var.yres_virtual;
 641         line_length = info->fix.line_length;
 642         rincr = (width + 7) / 8;
 643
 644         /* A shift below cannot cope with.  */
 645         if (unlikely(width == 0))
 646                 return;
 647         /* Crop the image to the screen.  */
 648         if (dx > vxres || dy > vyres)
 649                 return;
 650         if (dx + width > vxres)
 651                 width = vxres - dx;
 652         if (dy + height > vyres)
 653                 height = vyres - dy;
 654
 655         regs_base = par->tga_regs_base;
 656         fb_base = par->tga_fb_base;
 657
 658         /* Expand the color values to fill 32-bits.  */
 659         /* ??? Would be nice to notice colour changes elsewhere, so
 660            that we can do this only when necessary.  */
 661         fgcolor = image->fg_color;
 662         bgcolor = image->bg_color;
 663         if (is8bpp) {
 664                 fgcolor |= fgcolor << 8;
 665                 fgcolor |= fgcolor << 16;
 666                 bgcolor |= bgcolor << 8;
 667                 bgcolor |= bgcolor << 16;
 668         } else {
 669                 if (fgcolor < 16)
 670                         fgcolor = ((u32 *)info->pseudo_palette)[fgcolor];
 671                 if (bgcolor < 16)
 672                         bgcolor = ((u32 *)info->pseudo_palette)[bgcolor];
 673         }
 674         __raw_writel(fgcolor, regs_base + TGA_FOREGROUND_REG);
 675         __raw_writel(bgcolor, regs_base + TGA_BACKGROUND_REG);
 676
 677         /* Acquire proper alignment; set up the PIXELMASK register
 678            so that we only write the proper character cell.  */
 679         pos = dy * line_length;
 680         if (is8bpp) {
 681                 pos += dx;
 682                 shift = pos & 3;
 683                 pos &= -4;
 684         } else {
 685                 pos += dx * 4;
 686                 shift = (pos & 7) >> 2;
 687                 pos &= -8;
 688         }
 689
 690         data = (const unsigned char *) image->data;
 691
 692         /* Enable opaque stipple mode.  */
 693         __raw_writel((is8bpp
 694                       ? TGA_MODE_SBM_8BPP | TGA_MODE_OPAQUE_STIPPLE
 695                       : TGA_MODE_SBM_24BPP | TGA_MODE_OPAQUE_STIPPLE),
 696                      regs_base + TGA_MODE_REG);
 697
 698         if (width + shift <= 32) {
 699                 unsigned long bwidth;
 700
 701                 /* Handle common case of imaging a single character, in
 702                    a font less than or 32 pixels wide.  */
 703
 704                 /* Avoid a shift by 32; width > 0 implied.  */
 705                 pixelmask = (2ul << (width - 1)) - 1;
 706                 pixelmask <<= shift;
 707                 __raw_writel(pixelmask, regs_base + TGA_PIXELMASK_REG);
 708                 wmb();
 709
 710                 bwidth = (width + 7) / 8;
 711
 712                 for (i = 0; i < height; ++i) {
 713                         u32 mask = 0;
 714
 715                         /* The image data is bit big endian; we need
 716                            little endian.  */
 717                         for (j = 0; j < bwidth; ++j)
 718                                 mask |= bitrev8(data[j]) << (j * 8);
 719
 720                         __raw_writel(mask << shift, fb_base + pos);
 721
 722                         pos += line_length;
 723                         data += rincr;
 724                 }
 725                 wmb();
 726                 __raw_writel(0xffffffff, regs_base + TGA_PIXELMASK_REG);
 727         } else if (shift == 0) {
 728                 unsigned long pos0 = pos;
 729                 const unsigned char *data0 = data;
 730                 unsigned long bincr = (is8bpp ? 8 : 8*4);
 731                 unsigned long bwidth;
 732
 733                 /* Handle another common case in which accel_putcs
 734                    generates a large bitmap, which happens to be aligned.
 735                    Allow the tail to be misaligned.  This case is
 736                    interesting because we've not got to hold partial
 737                    bytes across the words being written.  */
 738
 739                 wmb();
 740
 741                 bwidth = (width / 8) & -4;
 742                 for (i = 0; i < height; ++i) {
 743                         for (j = 0; j < bwidth; j += 4) {
 744                                 u32 mask = 0;
 745                                 mask |= bitrev8(data[j+0]) << (0 * 8);
 746                                 mask |= bitrev8(data[j+1]) << (1 * 8);
 747                                 mask |= bitrev8(data[j+2]) << (2 * 8);
 748                                 mask |= bitrev8(data[j+3]) << (3 * 8);
 749                                 __raw_writel(mask, fb_base + pos + j*bincr);
 750                         }
 751                         pos += line_length;
 752                         data += rincr;
 753                 }
 754                 wmb();
 755
 756                 pixelmask = (1ul << (width & 31)) - 1;
 757                 if (pixelmask) {
 758                         __raw_writel(pixelmask, regs_base + TGA_PIXELMASK_REG);
 759                         wmb();
 760
 761                         pos = pos0 + bwidth*bincr;
 762                         data = data0 + bwidth;
 763                         bwidth = ((width & 31) + 7) / 8;
 764
 765                         for (i = 0; i < height; ++i) {
 766                                 u32 mask = 0;
 767                                 for (j = 0; j < bwidth; ++j)
 768                                         mask |= bitrev8(data[j]) << (j * 8);
 769                                 __raw_writel(mask, fb_base + pos);
 770                                 pos += line_length;
 771                                 data += rincr;
 772                         }
 773                         wmb();
 774                         __raw_writel(0xffffffff, regs_base + TGA_PIXELMASK_REG);
 775                 }
 776         } else {
 777                 unsigned long pos0 = pos;
 778                 const unsigned char *data0 = data;
 779                 unsigned long bincr = (is8bpp ? 8 : 8*4);
 780                 unsigned long bwidth;
 781
 782                 /* Finally, handle the generic case of misaligned start.
 783                    Here we split the write into 16-bit spans.  This allows
 784                    us to use only one pixel mask, instead of four as would
 785                    be required by writing 24-bit spans.  */
 786
 787                 pixelmask = 0xffff << shift;
 788                 __raw_writel(pixelmask, regs_base + TGA_PIXELMASK_REG);
 789                 wmb();
 790
 791                 bwidth = (width / 8) & -2;
 792                 for (i = 0; i < height; ++i) {
 793                         for (j = 0; j < bwidth; j += 2) {
 794                                 u32 mask = 0;
 795                                 mask |= bitrev8(data[j+0]) << (0 * 8);
 796                                 mask |= bitrev8(data[j+1]) << (1 * 8);
 797                                 mask <<= shift;
 798                                 __raw_writel(mask, fb_base + pos + j*bincr);
 799                         }
 800                         pos += line_length;
 801                         data += rincr;
 802                 }
 803                 wmb();
 804
 805                 pixelmask = ((1ul << (width & 15)) - 1) << shift;
 806                 if (pixelmask) {
 807                         __raw_writel(pixelmask, regs_base + TGA_PIXELMASK_REG);
 808                         wmb();
 809
 810                         pos = pos0 + bwidth*bincr;
 811                         data = data0 + bwidth;
 812                         bwidth = (width & 15) > 8;
 813
 814                         for (i = 0; i < height; ++i) {
 815                                 u32 mask = bitrev8(data[0]);
 816                                 if (bwidth)
 817                                         mask |= bitrev8(data[1]) << 8;
 818                                 mask <<= shift;
 819                                 __raw_writel(mask, fb_base + pos);
 820                                 pos += line_length;
 821                                 data += rincr;
 822                         }
 823                         wmb();
 824                 }
 825                 __raw_writel(0xffffffff, regs_base + TGA_PIXELMASK_REG);
 826         }
 827
 828         /* Disable opaque stipple mode.  */
 829         __raw_writel((is8bpp
 830                       ? TGA_MODE_SBM_8BPP | TGA_MODE_SIMPLE
 831                       : TGA_MODE_SBM_24BPP | TGA_MODE_SIMPLE),
 832                      regs_base + TGA_MODE_REG);
 833 }
 834
 835 static void
 836 tgafb_clut_imageblit(struct fb_info *info, const struct fb_image *image)
 837 {
 838         struct tga_par *par = (struct tga_par *) info->par;
 839         u32 color, dx, dy, width, height, vxres, vyres;
 840         u32 *palette = ((u32 *)info->pseudo_palette);
 841         unsigned long pos, line_length, i, j;
 842         const unsigned char *data;
 843         void __iomem *regs_base, *fb_base;
 844
 845         dx = image->dx;
 846         dy = image->dy;
 847         width = image->width;
 848         height = image->height;
 849         vxres = info->var.xres_virtual;
 850         vyres = info->var.yres_virtual;
 851         line_length = info->fix.line_length;
 852
 853         /* Crop the image to the screen.  */
 854         if (dx > vxres || dy > vyres)
 855                 return;
 856         if (dx + width > vxres)
 857                 width = vxres - dx;
 858         if (dy + height > vyres)
 859                 height = vyres - dy;
 860
 861         regs_base = par->tga_regs_base;
 862         fb_base = par->tga_fb_base;
 863
 864         pos = dy * line_length + (dx * 4);
 865         data = image->data;
 866
 867         /* Now copy the image, color_expanding via the palette. */
 868         for (i = 0; i < height; i++) {
 869                 for (j = 0; j < width; j++) {
 870                         color = palette[*data++];
 871                         __raw_writel(color, fb_base + pos + j*4);
 872                 }
 873                 pos += line_length;
 874         }
 875 }
 876
 877 /**
 878  *      tgafb_imageblit - REQUIRED function. Can use generic routines if
 879  *                        non acclerated hardware and packed pixel based.
 880  *                        Copies a image from system memory to the screen.
 881  *
 882  *      @info: frame buffer structure that represents a single frame buffer
 883  *      @image: structure defining the image.
 884  */
 885 static void
 886 tgafb_imageblit(struct fb_info *info, const struct fb_image *image)
 887 {
 888         unsigned int is8bpp = info->var.bits_per_pixel == 8;
 889
 890         /* If a mono image, regardless of FB depth, go do it. */
 891         if (image->depth == 1) {
 892                 tgafb_mono_imageblit(info, image);
 893                 return;
 894         }
 895
 896         /* For copies that aren't pixel expansion, there's little we
 897            can do better than the generic code.  */
 898         /* ??? There is a DMA write mode; I wonder if that could be
 899            made to pull the data from the image buffer...  */
 900         if (image->depth == info->var.bits_per_pixel) {
 901                 cfb_imageblit(info, image);
 902                 return;
 903         }
 904
 905         /* If 24-plane FB and the image is 8-plane with CLUT, we can do it. */
 906         if (!is8bpp && image->depth == 8) {
 907                 tgafb_clut_imageblit(info, image);
 908                 return;
 909         }
 910
 911         /* Silently return... */
 912 }
 913
 914 /**
 915  *      tgafb_fillrect - REQUIRED function. Can use generic routines if
 916  *                       non acclerated hardware and packed pixel based.
 917  *                       Draws a rectangle on the screen.
 918  *
 919  *      @info: frame buffer structure that represents a single frame buffer
 920  *      @rect: structure defining the rectagle and operation.
 921  */
 922 static void
 923 tgafb_fillrect(struct fb_info *info, const struct fb_fillrect *rect)
 924 {
 925         struct tga_par *par = (struct tga_par *) info->par;
 926         int is8bpp = info->var.bits_per_pixel == 8;
 927         u32 dx, dy, width, height, vxres, vyres, color;
 928         unsigned long pos, align, line_length, i, j;
 929         void __iomem *regs_base;
 930         void __iomem *fb_base;
 931
 932         dx = rect->dx;
 933         dy = rect->dy;
 934         width = rect->width;
 935         height = rect->height;
 936         vxres = info->var.xres_virtual;
 937         vyres = info->var.yres_virtual;
 938         line_length = info->fix.line_length;
 939         regs_base = par->tga_regs_base;
 940         fb_base = par->tga_fb_base;
 941
 942         /* Crop the rectangle to the screen.  */
 943         if (dx > vxres || dy > vyres || !width || !height)
 944                 return;
 945         if (dx + width > vxres)
 946                 width = vxres - dx;
 947         if (dy + height > vyres)
 948                 height = vyres - dy;
 949
 950         pos = dy * line_length + dx * (is8bpp ? 1 : 4);
 951
 952         /* ??? We could implement ROP_XOR with opaque fill mode
 953            and a RasterOp setting of GXxor, but as far as I can
 954            tell, this mode is not actually used in the kernel.
 955            Thus I am ignoring it for now.  */
 956         if (rect->rop != ROP_COPY) {
 957                 cfb_fillrect(info, rect);
 958                 return;
 959         }
 960
 961         /* Expand the color value to fill 8 pixels.  */
 962         color = rect->color;
 963         if (is8bpp) {
 964                 color |= color << 8;
 965                 color |= color << 16;
 966                 __raw_writel(color, regs_base + TGA_BLOCK_COLOR0_REG);
 967                 __raw_writel(color, regs_base + TGA_BLOCK_COLOR1_REG);
 968         } else {
 969                 if (color < 16)
 970                         color = ((u32 *)info->pseudo_palette)[color];
 971                 __raw_writel(color, regs_base + TGA_BLOCK_COLOR0_REG);
 972                 __raw_writel(color, regs_base + TGA_BLOCK_COLOR1_REG);
 973                 __raw_writel(color, regs_base + TGA_BLOCK_COLOR2_REG);
 974                 __raw_writel(color, regs_base + TGA_BLOCK_COLOR3_REG);
 975                 __raw_writel(color, regs_base + TGA_BLOCK_COLOR4_REG);
 976                 __raw_writel(color, regs_base + TGA_BLOCK_COLOR5_REG);
 977                 __raw_writel(color, regs_base + TGA_BLOCK_COLOR6_REG);
 978                 __raw_writel(color, regs_base + TGA_BLOCK_COLOR7_REG);
 979         }
 980
 981         /* The DATA register holds the fill mask for block fill mode.
 982            Since we're not stippling, this is all ones.  */
 983         __raw_writel(0xffffffff, regs_base + TGA_DATA_REG);
 984
 985         /* Enable block fill mode.  */
 986         __raw_writel((is8bpp
 987                       ? TGA_MODE_SBM_8BPP | TGA_MODE_BLOCK_FILL
 988                       : TGA_MODE_SBM_24BPP | TGA_MODE_BLOCK_FILL),
 989                      regs_base + TGA_MODE_REG);
 990         wmb();
 991
 992         /* We can fill 2k pixels per operation.  Notice blocks that fit
 993            the width of the screen so that we can take advantage of this
 994            and fill more than one line per write.  */
 995         if (width == line_length)
 996                 width *= height, height = 1;
 997
 998         /* The write into the frame buffer must be aligned to 4 bytes,
 999            but we are allowed to encode the offset within the word in
1000            the data word written.  */
1001         align = (pos & 3) << 16;
1002         pos &= -4;
1003
1004         if (width <= 2048) {
1005                 u32 data;
1006
1007                 data = (width - 1) | align;
1008
1009                 for (i = 0; i < height; ++i) {
1010                         __raw_writel(data, fb_base + pos);
1011                         pos += line_length;
1012                 }
1013         } else {
1014                 unsigned long Bpp = (is8bpp ? 1 : 4);
1015                 unsigned long nwidth = width & -2048;
1016                 u32 fdata, ldata;
1017
1018                 fdata = (2048 - 1) | align;
1019                 ldata = ((width & 2047) - 1) | align;
1020
1021                 for (i = 0; i < height; ++i) {
1022                         for (j = 0; j < nwidth; j += 2048)
1023                                 __raw_writel(fdata, fb_base + pos + j*Bpp);
1024                         if (j < width)
1025                                 __raw_writel(ldata, fb_base + pos + j*Bpp);
1026                         pos += line_length;
1027                 }
1028         }
1029         wmb();
1030
1031         /* Disable block fill mode.  */
1032         __raw_writel((is8bpp
1033                       ? TGA_MODE_SBM_8BPP | TGA_MODE_SIMPLE
1034                       : TGA_MODE_SBM_24BPP | TGA_MODE_SIMPLE),
1035                      regs_base + TGA_MODE_REG);
1036 }
1037
1038 /**
1039  *      tgafb_copyarea - REQUIRED function. Can use generic routines if
1040  *                       non acclerated hardware and packed pixel based.
1041  *                       Copies on area of the screen to another area.
1042  *
1043  *      @info: frame buffer structure that represents a single frame buffer
1044  *      @area: structure defining the source and destination.
1045  */
1046
1047 /* Handle the special case of copying entire lines, e.g. during scrolling.
1048    We can avoid a lot of needless computation in this case.  In the 8bpp
1049    case we need to use the COPY64 registers instead of mask writes into
1050    the frame buffer to achieve maximum performance.  */
1051
1052 static inline void
1053 copyarea_line_8bpp(struct fb_info *info, u32 dy, u32 sy,
1054                    u32 height, u32 width)
1055 {
1056         struct tga_par *par = (struct tga_par *) info->par;
1057         void __iomem *tga_regs = par->tga_regs_base;
1058         unsigned long dpos, spos, i, n64;
1059
1060         /* Set up the MODE and PIXELSHIFT registers.  */
1061         __raw_writel(TGA_MODE_SBM_8BPP | TGA_MODE_COPY, tga_regs+TGA_MODE_REG);
1062         __raw_writel(0, tga_regs+TGA_PIXELSHIFT_REG);
1063         wmb();
1064
1065         n64 = (height * width) / 64;
1066
1067         if (sy < dy) {
1068                 spos = (sy + height) * width;
1069                 dpos = (dy + height) * width;
1070
1071                 for (i = 0; i < n64; ++i) {
1072                         spos -= 64;
1073                         dpos -= 64;
1074                         __raw_writel(spos, tga_regs+TGA_COPY64_SRC);
1075                         wmb();
1076                         __raw_writel(dpos, tga_regs+TGA_COPY64_DST);
1077                         wmb();
1078                 }
1079         } else {
1080                 spos = sy * width;
1081                 dpos = dy * width;
1082
1083                 for (i = 0; i < n64; ++i) {
1084                         __raw_writel(spos, tga_regs+TGA_COPY64_SRC);
1085                         wmb();
1086                         __raw_writel(dpos, tga_regs+TGA_COPY64_DST);
1087                         wmb();
1088                         spos += 64;
1089                         dpos += 64;
1090                 }
1091         }
1092
1093         /* Reset the MODE register to normal.  */
1094         __raw_writel(TGA_MODE_SBM_8BPP|TGA_MODE_SIMPLE, tga_regs+TGA_MODE_REG);
1095 }
1096
1097 static inline void
1098 copyarea_line_32bpp(struct fb_info *info, u32 dy, u32 sy,
1099                     u32 height, u32 width)
1100 {
1101         struct tga_par *par = (struct tga_par *) info->par;
1102         void __iomem *tga_regs = par->tga_regs_base;
1103         void __iomem *tga_fb = par->tga_fb_base;
1104         void __iomem *src;
1105         void __iomem *dst;
1106         unsigned long i, n16;
1107
1108         /* Set up the MODE and PIXELSHIFT registers.  */
1109         __raw_writel(TGA_MODE_SBM_24BPP | TGA_MODE_COPY, tga_regs+TGA_MODE_REG);
1110         __raw_writel(0, tga_regs+TGA_PIXELSHIFT_REG);
1111         wmb();
1112
1113         n16 = (height * width) / 16;
1114
1115         if (sy < dy) {
1116                 src = tga_fb + (sy + height) * width * 4;
1117                 dst = tga_fb + (dy + height) * width * 4;
1118
1119                 for (i = 0; i < n16; ++i) {
1120                         src -= 64;
1121                         dst -= 64;
1122                         __raw_writel(0xffff, src);
1123                         wmb();
1124                         __raw_writel(0xffff, dst);
1125                         wmb();
1126                 }
1127         } else {
1128                 src = tga_fb + sy * width * 4;
1129                 dst = tga_fb + dy * width * 4;
1130
1131                 for (i = 0; i < n16; ++i) {
1132                         __raw_writel(0xffff, src);
1133                         wmb();
1134                         __raw_writel(0xffff, dst);
1135                         wmb();
1136                         src += 64;
1137                         dst += 64;
1138                 }
1139         }
1140
1141         /* Reset the MODE register to normal.  */
1142         __raw_writel(TGA_MODE_SBM_24BPP|TGA_MODE_SIMPLE, tga_regs+TGA_MODE_REG);
1143 }
1144
1145 /* The general case of forward copy in 8bpp mode.  */
1146 static inline void
1147 copyarea_foreward_8bpp(struct fb_info *info, u32 dx, u32 dy, u32 sx, u32 sy,
1148                        u32 height, u32 width, u32 line_length)
1149 {
1150         struct tga_par *par = (struct tga_par *) info->par;
1151         unsigned long i, copied, left;
1152         unsigned long dpos, spos, dalign, salign, yincr;
1153         u32 smask_first, dmask_first, dmask_last;
1154         int pixel_shift, need_prime, need_second;
1155         unsigned long n64, n32, xincr_first;
1156         void __iomem *tga_regs;
1157         void __iomem *tga_fb;
1158
1159         yincr = line_length;
1160         if (dy > sy) {
1161                 dy += height - 1;
1162                 sy += height - 1;
1163                 yincr = -yincr;
1164         }
1165
1166         /* Compute the offsets and alignments in the frame buffer.
1167            More than anything else, these control how we do copies.  */
1168         dpos = dy * line_length + dx;
1169         spos = sy * line_length + sx;
1170         dalign = dpos & 7;
1171         salign = spos & 7;
1172         dpos &= -8;
1173         spos &= -8;
1174
1175         /* Compute the value for the PIXELSHIFT register.  This controls
1176            both non-co-aligned source and destination and copy direction.  */
1177         if (dalign >= salign)
1178                 pixel_shift = dalign - salign;
1179         else
1180                 pixel_shift = 8 - (salign - dalign);
1181
1182         /* Figure out if we need an additional priming step for the
1183            residue register.  */
1184         need_prime = (salign > dalign);
1185         if (need_prime)
1186                 dpos -= 8;
1187
1188         /* Begin by copying the leading unaligned destination.  Copy enough
1189            to make the next destination address 32-byte aligned.  */
1190         copied = 32 - (dalign + (dpos & 31));
1191         if (copied == 32)
1192                 copied = 0;
1193         xincr_first = (copied + 7) & -8;
1194         smask_first = dmask_first = (1ul << copied) - 1;
1195         smask_first <<= salign;
1196         dmask_first <<= dalign + need_prime*8;
1197         if (need_prime && copied > 24)
1198                 copied -= 8;
1199         left = width - copied;
1200
1201         /* Care for small copies.  */
1202         if (copied > width) {
1203                 u32 t;
1204                 t = (1ul << width) - 1;
1205                 t <<= dalign + need_prime*8;
1206                 dmask_first &= t;
1207                 left = 0;
1208         }
1209
1210         /* Attempt to use 64-byte copies.  This is only possible if the
1211            source and destination are co-aligned at 64 bytes.  */
1212         n64 = need_second = 0;
1213         if ((dpos & 63) == (spos & 63)
1214             && (height == 1 || line_length % 64 == 0)) {
1215                 /* We may need a 32-byte copy to ensure 64 byte alignment.  */
1216                 need_second = (dpos + xincr_first) & 63;
1217                 if ((need_second & 32) != need_second)
1218                         printk(KERN_ERR "tgafb: need_second wrong\n");
1219                 if (left >= need_second + 64) {
1220                         left -= need_second;
1221                         n64 = left / 64;
1222                         left %= 64;
1223                 } else
1224                         need_second = 0;
1225         }
1226
1227         /* Copy trailing full 32-byte sections.  This will be the main
1228            loop if the 64 byte loop can't be used.  */
1229         n32 = left / 32;
1230         left %= 32;
1231
1232         /* Copy the trailing unaligned destination.  */
1233         dmask_last = (1ul << left) - 1;
1234
1235         tga_regs = par->tga_regs_base;
1236         tga_fb = par->tga_fb_base;
1237
1238         /* Set up the MODE and PIXELSHIFT registers.  */
1239         __raw_writel(TGA_MODE_SBM_8BPP|TGA_MODE_COPY, tga_regs+TGA_MODE_REG);
1240         __raw_writel(pixel_shift, tga_regs+TGA_PIXELSHIFT_REG);
1241         wmb();
1242
1243         for (i = 0; i < height; ++i) {
1244                 unsigned long j;
1245                 void __iomem *sfb;
1246                 void __iomem *dfb;
1247
1248                 sfb = tga_fb + spos;
1249                 dfb = tga_fb + dpos;
1250                 if (dmask_first) {
1251                         __raw_writel(smask_first, sfb);
1252                         wmb();
1253                         __raw_writel(dmask_first, dfb);
1254                         wmb();
1255                         sfb += xincr_first;
1256                         dfb += xincr_first;
1257                 }
1258
1259                 if (need_second) {
1260                         __raw_writel(0xffffffff, sfb);
1261                         wmb();
1262                         __raw_writel(0xffffffff, dfb);
1263                         wmb();
1264                         sfb += 32;
1265                         dfb += 32;
1266                 }
1267
1268                 if (n64 && (((unsigned long)sfb | (unsigned long)dfb) & 63))
1269                         printk(KERN_ERR
1270                                "tgafb: misaligned copy64 (s:%p, d:%p)\n",
1271                                sfb, dfb);
1272
1273                 for (j = 0; j < n64; ++j) {
1274                         __raw_writel(sfb - tga_fb, tga_regs+TGA_COPY64_SRC);
1275                         wmb();
1276                         __raw_writel(dfb - tga_fb, tga_regs+TGA_COPY64_DST);
1277                         wmb();
1278                         sfb += 64;
1279                         dfb += 64;
1280                 }
1281
1282                 for (j = 0; j < n32; ++j) {
1283                         __raw_writel(0xffffffff, sfb);
1284                         wmb();
1285                         __raw_writel(0xffffffff, dfb);
1286                         wmb();
1287                         sfb += 32;
1288                         dfb += 32;
1289                 }
1290
1291                 if (dmask_last) {
1292                         __raw_writel(0xffffffff, sfb);
1293                         wmb();
1294                         __raw_writel(dmask_last, dfb);
1295                         wmb();
1296                 }
1297
1298                 spos += yincr;
1299                 dpos += yincr;
1300         }
1301
1302         /* Reset the MODE register to normal.  */
1303         __raw_writel(TGA_MODE_SBM_8BPP|TGA_MODE_SIMPLE, tga_regs+TGA_MODE_REG);
1304 }
1305
1306 /* The (almost) general case of backward copy in 8bpp mode.  */
1307 static inline void
1308 copyarea_backward_8bpp(struct fb_info *info, u32 dx, u32 dy, u32 sx, u32 sy,
1309                        u32 height, u32 width, u32 line_length,
1310                        const struct fb_copyarea *area)
1311 {
1312         struct tga_par *par = (struct tga_par *) info->par;
1313         unsigned long i, left, yincr;
1314         unsigned long depos, sepos, dealign, sealign;
1315         u32 mask_first, mask_last;
1316         unsigned long n32;
1317         void __iomem *tga_regs;
1318         void __iomem *tga_fb;
1319
1320         yincr = line_length;
1321         if (dy > sy) {
1322                 dy += height - 1;
1323                 sy += height - 1;
1324                 yincr = -yincr;
1325         }
1326
1327         /* Compute the offsets and alignments in the frame buffer.
1328            More than anything else, these control how we do copies.  */
1329         depos = dy * line_length + dx + width;
1330         sepos = sy * line_length + sx + width;
1331         dealign = depos & 7;
1332         sealign = sepos & 7;
1333
1334         /* ??? The documentation appears to be incorrect (or very
1335            misleading) wrt how pixel shifting works in backward copy
1336            mode, i.e. when PIXELSHIFT is negative.  I give up for now.
1337            Do handle the common case of co-aligned backward copies,
1338            but frob everything else back on generic code.  */
1339         if (dealign != sealign) {
1340                 cfb_copyarea(info, area);
1341                 return;
1342         }
1343
1344         /* We begin the copy with the trailing pixels of the
1345            unaligned destination.  */
1346         mask_first = (1ul << dealign) - 1;
1347         left = width - dealign;
1348
1349         /* Care for small copies.  */
1350         if (dealign > width) {
1351                 mask_first ^= (1ul << (dealign - width)) - 1;
1352                 left = 0;
1353         }
1354
1355         /* Next copy full words at a time.  */
1356         n32 = left / 32;
1357         left %= 32;
1358
1359         /* Finally copy the unaligned head of the span.  */
1360         mask_last = -1 << (32 - left);
1361
1362         tga_regs = par->tga_regs_base;
1363         tga_fb = par->tga_fb_base;
1364
1365         /* Set up the MODE and PIXELSHIFT registers.  */
1366         __raw_writel(TGA_MODE_SBM_8BPP|TGA_MODE_COPY, tga_regs+TGA_MODE_REG);
1367         __raw_writel(0, tga_regs+TGA_PIXELSHIFT_REG);
1368         wmb();
1369
1370         for (i = 0; i < height; ++i) {
1371                 unsigned long j;
1372                 void __iomem *sfb;
1373                 void __iomem *dfb;
1374
1375                 sfb = tga_fb + sepos;
1376                 dfb = tga_fb + depos;
1377                 if (mask_first) {
1378                         __raw_writel(mask_first, sfb);
1379                         wmb();
1380                         __raw_writel(mask_first, dfb);
1381                         wmb();
1382                 }
1383
1384                 for (j = 0; j < n32; ++j) {
1385                         sfb -= 32;
1386                         dfb -= 32;
1387                         __raw_writel(0xffffffff, sfb);
1388                         wmb();
1389                         __raw_writel(0xffffffff, dfb);
1390                         wmb();
1391                 }
1392
1393                 if (mask_last) {
1394                         sfb -= 32;
1395                         dfb -= 32;
1396                         __raw_writel(mask_last, sfb);
1397                         wmb();
1398                         __raw_writel(mask_last, dfb);
1399                         wmb();
1400                 }
1401
1402                 sepos += yincr;
1403                 depos += yincr;
1404         }
1405
1406         /* Reset the MODE register to normal.  */
1407         __raw_writel(TGA_MODE_SBM_8BPP|TGA_MODE_SIMPLE, tga_regs+TGA_MODE_REG);
1408 }
1409
1410 static void
1411 tgafb_copyarea(struct fb_info *info, const struct fb_copyarea *area)
1412 {
1413         unsigned long dx, dy, width, height, sx, sy, vxres, vyres;
1414         unsigned long line_length, bpp;
1415
1416         dx = area->dx;
1417         dy = area->dy;
1418         width = area->width;
1419         height = area->height;
1420         sx = area->sx;
1421         sy = area->sy;
1422         vxres = info->var.xres_virtual;
1423         vyres = info->var.yres_virtual;
1424         line_length = info->fix.line_length;
1425
1426         /* The top left corners must be in the virtual screen.  */
1427         if (dx > vxres || sx > vxres || dy > vyres || sy > vyres)
1428                 return;
1429
1430         /* Clip the destination.  */
1431         if (dx + width > vxres)
1432                 width = vxres - dx;
1433         if (dy + height > vyres)
1434                 height = vyres - dy;
1435
1436         /* The source must be completely inside the virtual screen.  */
1437         if (sx + width > vxres || sy + height > vyres)
1438                 return;
1439
1440         bpp = info->var.bits_per_pixel;
1441
1442         /* Detect copies of the entire line.  */
1443         if (width * (bpp >> 3) == line_length) {
1444                 if (bpp == 8)
1445                         copyarea_line_8bpp(info, dy, sy, height, width);
1446                 else
1447                         copyarea_line_32bpp(info, dy, sy, height, width);
1448         }
1449
1450         /* ??? The documentation is unclear to me exactly how the pixelshift
1451            register works in 32bpp mode.  Since I don't have hardware to test,
1452            give up for now and fall back on the generic routines.  */
1453         else if (bpp == 32)
1454                 cfb_copyarea(info, area);
1455
1456         /* Detect overlapping source and destination that requires
1457            a backward copy.  */
1458         else if (dy == sy && dx > sx && dx < sx + width)
1459                 copyarea_backward_8bpp(info, dx, dy, sx, sy, height,
1460                                        width, line_length, area);
1461         else
1462                 copyarea_foreward_8bpp(info, dx, dy, sx, sy, height,
1463                                        width, line_length);
1464 }
1465
1466
1467 /*
1468  *  Initialisation
1469  */
1470
1471 static void
1472 tgafb_init_fix(struct fb_info *info)
1473 {
1474         struct tga_par *par = (struct tga_par *)info->par;
1475         int tga_bus_pci = TGA_BUS_PCI(par->dev);
1476         int tga_bus_tc = TGA_BUS_TC(par->dev);
1477         u8 tga_type = par->tga_type;
1478         const char *tga_type_name = NULL;
1479
1480         switch (tga_type) {
1481         case TGA_TYPE_8PLANE:
1482                 if (tga_bus_pci)
1483                         tga_type_name = "Digital ZLXp-E1";
1484                 if (tga_bus_tc)
1485                         tga_type_name = "Digital ZLX-E1";
1486                 break;
1487         case TGA_TYPE_24PLANE:
1488                 if (tga_bus_pci)
1489                         tga_type_name = "Digital ZLXp-E2";
1490                 if (tga_bus_tc)
1491                         tga_type_name = "Digital ZLX-E2";
1492                 break;
1493         case TGA_TYPE_24PLUSZ:
1494                 if (tga_bus_pci)
1495                         tga_type_name = "Digital ZLXp-E3";
1496                 if (tga_bus_tc)
1497                         tga_type_name = "Digital ZLX-E3";
1498                 break;
1499         default:
1500                 tga_type_name = "Unknown";
1501                 break;
1502         }
1503
1504         strlcpy(info->fix.id, tga_type_name, sizeof(info->fix.id));
1505
1506         info->fix.type = FB_TYPE_PACKED_PIXELS;
1507         info->fix.type_aux = 0;
1508         info->fix.visual = (tga_type == TGA_TYPE_8PLANE
1509                             ? FB_VISUAL_PSEUDOCOLOR
1510                             : FB_VISUAL_DIRECTCOLOR);
1511
1512         info->fix.line_length = par->xres * (par->bits_per_pixel >> 3);
1513         info->fix.smem_start = (size_t) par->tga_fb_base;
1514         info->fix.smem_len = info->fix.line_length * par->yres;
1515         info->fix.mmio_start = (size_t) par->tga_regs_base;
1516         info->fix.mmio_len = 512;
1517
1518         info->fix.xpanstep = 0;
1519         info->fix.ypanstep = 0;
1520         info->fix.ywrapstep = 0;
1521
1522         info->fix.accel = FB_ACCEL_DEC_TGA;
1523
1524         /*
1525          * These are needed by fb_set_logo_truepalette(), so we
1526          * set them here for 24-plane cards.
1527          */
1528         if (tga_type != TGA_TYPE_8PLANE) {
1529                 info->var.red.length = 8;
1530                 info->var.green.length = 8;
1531                 info->var.blue.length = 8;
1532                 info->var.red.offset = 16;
1533                 info->var.green.offset = 8;
1534                 info->var.blue.offset = 0;
1535         }
1536 }
1537
1538 static int tgafb_pan_display(struct fb_var_screeninfo *var, struct fb_info *info)
1539 {
1540         /* We just use this to catch switches out of graphics mode. */
1541         tgafb_set_par(info); /* A bit of overkill for BASE_ADDR reset. */
1542         return 0;
1543 }
1544
1545 static int tgafb_register(struct device *dev)
1546 {
1547         static const struct fb_videomode modedb_tc = {
1548                 /* 1280x1024 @ 72 Hz, 76.8 kHz hsync */
1549                 "1280x1024@72", 0, 1280, 1024, 7645, 224, 28, 33, 3, 160, 3,
1550                 FB_SYNC_ON_GREEN, FB_VMODE_NONINTERLACED
1551         };
1552
1553         static unsigned int const fb_offset_presets[4] = {
1554                 TGA_8PLANE_FB_OFFSET,
1555                 TGA_24PLANE_FB_OFFSET,
1556                 0xffffffff,
1557                 TGA_24PLUSZ_FB_OFFSET
1558         };
1559
1560         const struct fb_videomode *modedb_tga = NULL;
1561         resource_size_t bar0_start = 0, bar0_len = 0;
1562         const char *mode_option_tga = NULL;
1563         int tga_bus_pci = TGA_BUS_PCI(dev);
1564         int tga_bus_tc = TGA_BUS_TC(dev);
1565         unsigned int modedbsize_tga = 0;
1566         void __iomem *mem_base;
1567         struct fb_info *info;
1568         struct tga_par *par;
1569         u8 tga_type;
1570         int ret = 0;
1571
1572         /* Enable device in PCI config.  */
1573         if (tga_bus_pci && pci_enable_device(to_pci_dev(dev))) {
1574                 printk(KERN_ERR "tgafb: Cannot enable PCI device\n");
1575                 return -ENODEV;
1576         }
1577
1578         /* Allocate the fb and par structures.  */
1579         info = framebuffer_alloc(sizeof(struct tga_par), dev);
1580         if (!info) {
1581                 printk(KERN_ERR "tgafb: Cannot allocate memory\n");
1582                 return -ENOMEM;
1583         }
1584
1585         par = info->par;
1586         dev_set_drvdata(dev, info);
1587
1588         /* Request the mem regions.  */
1589         ret = -ENODEV;
1590         if (tga_bus_pci) {
1591                 bar0_start = pci_resource_start(to_pci_dev(dev), 0);
1592                 bar0_len = pci_resource_len(to_pci_dev(dev), 0);
1593         }
1594         if (tga_bus_tc) {
1595                 bar0_start = to_tc_dev(dev)->resource.start;
1596                 bar0_len = to_tc_dev(dev)->resource.end - bar0_start + 1;
1597         }
1598         if (!request_mem_region (bar0_start, bar0_len, "tgafb")) {
1599                 printk(KERN_ERR "tgafb: cannot reserve FB region\n");
1600                 goto err0;
1601         }
1602
1603         /* Map the framebuffer.  */
1604         mem_base = ioremap_nocache(bar0_start, bar0_len);
1605         if (!mem_base) {
1606                 printk(KERN_ERR "tgafb: Cannot map MMIO\n");
1607                 goto err1;
1608         }
1609
1610         /* Grab info about the card.  */
1611         tga_type = (readl(mem_base) >> 12) & 0x0f;
1612         par->dev = dev;
1613         par->tga_mem_base = mem_base;
1614         par->tga_fb_base = mem_base + fb_offset_presets[tga_type];
1615         par->tga_regs_base = mem_base + TGA_REGS_OFFSET;
1616         par->tga_type = tga_type;
1617         if (tga_bus_pci)
1618                 par->tga_chip_rev = (to_pci_dev(dev))->revision;
1619         if (tga_bus_tc)
1620                 par->tga_chip_rev = TGA_READ_REG(par, TGA_START_REG) & 0xff;
1621
1622         /* Setup framebuffer.  */
1623         info->flags = FBINFO_DEFAULT | FBINFO_HWACCEL_COPYAREA |
1624                       FBINFO_HWACCEL_IMAGEBLIT | FBINFO_HWACCEL_FILLRECT;
1625         info->fbops = &tgafb_ops;
1626         info->screen_base = par->tga_fb_base;
1627         info->pseudo_palette = par->palette;
1628
1629         /* This should give a reasonable default video mode.  */
1630         if (tga_bus_pci) {
1631                 mode_option_tga = mode_option_pci;
1632         }
1633         if (tga_bus_tc) {
1634                 mode_option_tga = mode_option_tc;
1635                 modedb_tga = &modedb_tc;
1636                 modedbsize_tga = 1;
1637         }
1638         ret = fb_find_mode(&info->var, info,
1639                            mode_option ? mode_option : mode_option_tga,
1640                            modedb_tga, modedbsize_tga, NULL,
1641                            tga_type == TGA_TYPE_8PLANE ? 8 : 32);
1642         if (ret == 0 || ret == 4) {
1643                 printk(KERN_ERR "tgafb: Could not find valid video mode\n");
1644                 ret = -EINVAL;
1645                 goto err1;
1646         }
1647
1648         if (fb_alloc_cmap(&info->cmap, 256, 0)) {
1649                 printk(KERN_ERR "tgafb: Could not allocate color map\n");
1650                 ret = -ENOMEM;
1651                 goto err1;
1652         }
1653
1654         tgafb_set_par(info);
1655         tgafb_init_fix(info);
1656
1657         if (register_framebuffer(info) < 0) {
1658                 printk(KERN_ERR "tgafb: Could not register framebuffer\n");
1659                 ret = -EINVAL;
1660                 goto err2;
1661         }
1662
1663         if (tga_bus_pci) {
1664                 pr_info("tgafb: DC21030 [TGA] detected, rev=0x%02x\n",
1665                         par->tga_chip_rev);
1666                 pr_info("tgafb: at PCI bus %d, device %d, function %d\n",
1667                         to_pci_dev(dev)->bus->number,
1668                         PCI_SLOT(to_pci_dev(dev)->devfn),
1669                         PCI_FUNC(to_pci_dev(dev)->devfn));
1670         }
1671         if (tga_bus_tc)
1672                 pr_info("tgafb: SFB+ detected, rev=0x%02x\n",
1673                         par->tga_chip_rev);
1674         pr_info("fb%d: %s frame buffer device at 0x%lx\n",
1675                 info->node, info->fix.id, (long)bar0_start);
1676
1677         return 0;
1678
1679  err2:
1680         fb_dealloc_cmap(&info->cmap);
1681  err1:
1682         if (mem_base)
1683                 iounmap(mem_base);
1684         release_mem_region(bar0_start, bar0_len);
1685  err0:
1686         framebuffer_release(info);
1687         return ret;
1688 }
1689
1690 static void tgafb_unregister(struct device *dev)
1691 {
1692         resource_size_t bar0_start = 0, bar0_len = 0;
1693         int tga_bus_pci = TGA_BUS_PCI(dev);
1694         int tga_bus_tc = TGA_BUS_TC(dev);
1695         struct fb_info *info = NULL;
1696         struct tga_par *par;
1697
1698         info = dev_get_drvdata(dev);
1699         if (!info)
1700                 return;
1701
1702         par = info->par;
1703         unregister_framebuffer(info);
1704         fb_dealloc_cmap(&info->cmap);
1705         iounmap(par->tga_mem_base);
1706         if (tga_bus_pci) {
1707                 bar0_start = pci_resource_start(to_pci_dev(dev), 0);
1708                 bar0_len = pci_resource_len(to_pci_dev(dev), 0);
1709         }
1710         if (tga_bus_tc) {
1711                 bar0_start = to_tc_dev(dev)->resource.start;
1712                 bar0_len = to_tc_dev(dev)->resource.end - bar0_start + 1;
1713         }
1714         release_mem_region(bar0_start, bar0_len);
1715         framebuffer_release(info);
1716 }
1717
1718 static void tgafb_exit(void)
1719 {
1720         tc_unregister_driver(&tgafb_tc_driver);
1721         pci_unregister_driver(&tgafb_pci_driver);
1722 }
1723
1724 #ifndef MODULE
1725 static int tgafb_setup(char *arg)
1726 {
1727         char *this_opt;
1728
1729         if (arg && *arg) {
1730                 while ((this_opt = strsep(&arg, ","))) {
1731                         if (!*this_opt)
1732                                 continue;
1733                         if (!strncmp(this_opt, "mode:", 5))
1734                                 mode_option = this_opt+5;
1735                         else
1736                                 printk(KERN_ERR
1737                                        "tgafb: unknown parameter %s\n",
1738                                        this_opt);
1739                 }
1740         }
1741
1742         return 0;
1743 }
1744 #endif /* !MODULE */
1745
1746 static int tgafb_init(void)
1747 {
1748         int status;
1749 #ifndef MODULE
1750         char *option = NULL;
1751
1752         if (fb_get_options("tgafb", &option))
1753                 return -ENODEV;
1754         tgafb_setup(option);
1755 #endif
1756         status = pci_register_driver(&tgafb_pci_driver);
1757         if (!status)
1758                 status = tc_register_driver(&tgafb_tc_driver);
1759         return status;
1760 }
1761
1762 /*
1763  *  Modularisation
1764  */
1765
1766 module_init(tgafb_init);
1767 module_exit(tgafb_exit);
1768
1769 MODULE_DESCRIPTION("Framebuffer driver for TGA/SFB+ chipset");
1770 MODULE_LICENSE("GPL");