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