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