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

   1 /*
   2  *  linux/drivers/video/S3Triofb.c -- Open Firmware based frame buffer device
   3  *
   4  *      Copyright (C) 1997 Peter De Schrijver
   5  *
   6  *  This driver is partly based on the PowerMac console driver:
   7  *
   8  *      Copyright (C) 1996 Paul Mackerras
   9  *
  10  *  and on the Open Firmware based frame buffer device:
  11  *
  12  *      Copyright (C) 1997 Geert Uytterhoeven
  13  *
  14  *  This file is subject to the terms and conditions of the GNU General Public
  15  *  License. See the file COPYING in the main directory of this archive for
  16  *  more details.
  17  */
  18
  19 /*
  20         Bugs : + OF dependencies should be removed.
  21                + This driver should be merged with the CyberVision driver. The
  22                  CyberVision is a Zorro III implementation of the S3Trio64 chip.
  23
  24 */
  25
  26 #include <linux/config.h>
  27 #include <linux/kernel.h>
  28 #include <linux/module.h>
  29 #include <linux/errno.h>
  30 #include <linux/string.h>
  31 #include <linux/mm.h>
  32 #include <linux/tty.h>
  33 #include <linux/slab.h>
  34 #include <linux/vmalloc.h>
  35 #include <linux/delay.h>
  36 #include <linux/interrupt.h>
  37 #include <linux/fb.h>
  38 #include <linux/init.h>
  39 #include <linux/selection.h>
  40 #include <asm/io.h>
  41 #include <asm/prom.h>
  42 #include <asm/pci-bridge.h>
  43 #include <linux/pci.h>
  44
  45 #include <video/fbcon.h>
  46 #include <video/fbcon-cfb8.h>
  47 #include <video/s3blit.h>
  48
  49
  50 #define mem_in8(addr)           in_8((void *)(addr))
  51 #define mem_in16(addr)          in_le16((void *)(addr))
  52 #define mem_in32(addr)          in_le32((void *)(addr))
  53
  54 #define mem_out8(val, addr)     out_8((void *)(addr), val)
  55 #define mem_out16(val, addr)    out_le16((void *)(addr), val)
  56 #define mem_out32(val, addr)    out_le32((void *)(addr), val)
  57
  58 #define IO_OUT16VAL(v, r)       (((v) << 8) | (r))
  59
  60 static struct display disp;
  61 static struct fb_info fb_info;
  62 static struct { u_char red, green, blue, pad; } palette[256];
  63 static char s3trio_name[16] = "S3Trio ";
  64 static char *s3trio_base;
  65
  66 static struct fb_fix_screeninfo fb_fix;
  67 static struct fb_var_screeninfo fb_var = { 0, };
  68
  69
  70     /*
  71      *  Interface used by the world
  72      */
  73
  74 static void __init s3triofb_of_init(struct device_node *dp);
  75 static int s3trio_get_fix(struct fb_fix_screeninfo *fix, int con,
  76                           struct fb_info *info);
  77 static int s3trio_get_var(struct fb_var_screeninfo *var, int con,
  78                           struct fb_info *info);
  79 static int s3trio_set_var(struct fb_var_screeninfo *var, int con,
  80                           struct fb_info *info);
  81 static int s3trio_get_cmap(struct fb_cmap *cmap, int kspc, int con,
  82                            struct fb_info *info);
  83 static int s3trio_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
  84                          u_int transp, struct fb_info *info);
  85 static int s3trio_pan_display(struct fb_var_screeninfo *var, int con,
  86                               struct fb_info *info);
  87 static void s3triofb_blank(int blank, struct fb_info *info);
  88
  89     /*
  90      *  Interface to the low level console driver
  91      */
  92
  93 int s3triofb_init(void);
  94 static int s3triofbcon_switch(int con, struct fb_info *info);
  95 static int s3triofbcon_updatevar(int con, struct fb_info *info);
  96
  97     /*
  98      *  Text console acceleration
  99      */
 100
 101 #ifdef FBCON_HAS_CFB8
 102 static struct display_switch fbcon_trio8;
 103 #endif
 104
 105     /*
 106      *    Accelerated Functions used by the low level console driver
 107      */
 108
 109 static void Trio_WaitQueue(u_short fifo);
 110 static void Trio_WaitBlit(void);
 111 static void Trio_BitBLT(u_short curx, u_short cury, u_short destx,
 112                         u_short desty, u_short width, u_short height,
 113                         u_short mode);
 114 static void Trio_RectFill(u_short x, u_short y, u_short width, u_short height,
 115                           u_short mode, u_short color);
 116 static void Trio_MoveCursor(u_short x, u_short y);
 117
 118
 119     /*
 120      *  Internal routines
 121      */
 122
 123 static int s3trio_getcolreg(u_int regno, u_int *red, u_int *green, u_int *blue,
 124                          u_int *transp, struct fb_info *info);
 125
 126 static struct fb_ops s3trio_ops = {
 127         .owner =        THIS_MODULE,
 128         .fb_get_fix =   s3trio_get_fix,
 129         .fb_get_var =   s3trio_get_var,
 130         .fb_set_var =   s3trio_set_var,
 131         .fb_get_cmap =  s3trio_get_cmap,
 132         .fb_set_cmap =  gen_set_cmap,
 133         .fb_setcolreg = s3trio_setcolreg,
 134         .fb_pan_display =s3trio_pan_display,
 135         .fb_blank =     s3triofb_blank,
 136 };
 137
 138     /*
 139      *  Get the Fixed Part of the Display
 140      */
 141
 142 static int s3trio_get_fix(struct fb_fix_screeninfo *fix, int con,
 143                           struct fb_info *info)
 144 {
 145     memcpy(fix, &fb_fix, sizeof(fb_fix));
 146     return 0;
 147 }
 148
 149
 150     /*
 151      *  Get the User Defined Part of the Display
 152      */
 153
 154 static int s3trio_get_var(struct fb_var_screeninfo *var, int con,
 155                           struct fb_info *info)
 156 {
 157     memcpy(var, &fb_var, sizeof(fb_var));
 158     return 0;
 159 }
 160
 161
 162     /*
 163      *  Set the User Defined Part of the Display
 164      */
 165
 166 static int s3trio_set_var(struct fb_var_screeninfo *var, int con,
 167                           struct fb_info *info)
 168 {
 169     if (var->xres > fb_var.xres || var->yres > fb_var.yres ||
 170         var->bits_per_pixel > fb_var.bits_per_pixel )
 171         /* || var->nonstd || var->vmode != FB_VMODE_NONINTERLACED) */
 172         return -EINVAL;
 173     if (var->xres_virtual > fb_var.xres_virtual) {
 174         outw(IO_OUT16VAL((var->xres_virtual /8) & 0xff, 0x13), 0x3d4);
 175         outw(IO_OUT16VAL(((var->xres_virtual /8 ) & 0x300) >> 3, 0x51), 0x3d4);
 176         fb_var.xres_virtual = var->xres_virtual;
 177         fb_fix.line_length = var->xres_virtual;
 178     }
 179     fb_var.yres_virtual = var->yres_virtual;
 180     memcpy(var, &fb_var, sizeof(fb_var));
 181     return 0;
 182 }
 183
 184
 185     /*
 186      *  Pan or Wrap the Display
 187      *
 188      *  This call looks only at xoffset, yoffset and the FB_VMODE_YWRAP flag
 189      */
 190
 191 static int s3trio_pan_display(struct fb_var_screeninfo *var, int con,
 192                               struct fb_info *info)
 193 {
 194     unsigned int base;
 195
 196     if (var->xoffset > (var->xres_virtual - var->xres))
 197         return -EINVAL;
 198     if (var->yoffset > (var->yres_virtual - var->yres))
 199         return -EINVAL;
 200
 201     fb_var.xoffset = var->xoffset;
 202     fb_var.yoffset = var->yoffset;
 203
 204     base = var->yoffset * fb_fix.line_length + var->xoffset;
 205
 206     outw(IO_OUT16VAL((base >> 8) & 0xff, 0x0c),0x03D4);
 207     outw(IO_OUT16VAL(base  & 0xff, 0x0d),0x03D4);
 208     outw(IO_OUT16VAL((base >> 16) & 0xf, 0x69),0x03D4);
 209     return 0;
 210 }
 211
 212
 213     /*
 214      *  Get the Colormap
 215      */
 216
 217 static int s3trio_get_cmap(struct fb_cmap *cmap, int kspc, int con,
 218                            struct fb_info *info)
 219 {
 220     if (con == info->currcon) /* current console? */
 221         return fb_get_cmap(cmap, kspc, s3trio_getcolreg, info);
 222     else if (fb_display[con].cmap.len) /* non default colormap? */
 223         fb_copy_cmap(&fb_display[con].cmap, cmap, kspc ? 0 : 2);
 224     else
 225         fb_copy_cmap(fb_default_cmap(1 << fb_display[con].var.bits_per_pixel),
 226                      cmap, kspc ? 0 : 2);
 227     return 0;
 228 }
 229
 230 int __init s3triofb_init(void)
 231 {
 232         struct device_node *dp;
 233
 234         dp = find_devices("S3Trio");
 235         if (dp != 0)
 236             s3triofb_of_init(dp);
 237         return 0;
 238 }
 239
 240 void __init s3trio_resetaccel(void){
 241
 242
 243 #define EC01_ENH_ENB    0x0005
 244 #define EC01_LAW_ENB    0x0010
 245 #define EC01_MMIO_ENB   0x0020
 246
 247 #define EC00_RESET      0x8000
 248 #define EC00_ENABLE     0x4000
 249 #define MF_MULT_MISC    0xE000
 250 #define SRC_FOREGROUND  0x0020
 251 #define SRC_BACKGROUND  0x0000
 252 #define MIX_SRC                 0x0007
 253 #define MF_T_CLIP       0x1000
 254 #define MF_L_CLIP       0x2000
 255 #define MF_B_CLIP       0x3000
 256 #define MF_R_CLIP       0x4000
 257 #define MF_PIX_CONTROL  0xA000
 258 #define MFA_SRC_FOREGR_MIX      0x0000
 259 #define MF_PIX_CONTROL  0xA000
 260
 261         outw(EC00_RESET,  0x42e8);
 262         inw(  0x42e8);
 263         outw(EC00_ENABLE,  0x42e8);
 264         inw(  0x42e8);
 265         outw(EC01_ENH_ENB | EC01_LAW_ENB,
 266                    0x4ae8);
 267         outw(MF_MULT_MISC,  0xbee8); /* 16 bit I/O registers */
 268
 269         /* Now set some basic accelerator registers */
 270         Trio_WaitQueue(0x0400);
 271         outw(SRC_FOREGROUND | MIX_SRC, 0xbae8);
 272         outw(SRC_BACKGROUND | MIX_SRC,  0xb6e8);/* direct color*/
 273         outw(MF_T_CLIP | 0, 0xbee8 );     /* clip virtual area  */
 274         outw(MF_L_CLIP | 0, 0xbee8 );
 275         outw(MF_R_CLIP | (640 - 1), 0xbee8);
 276         outw(MF_B_CLIP | (480 - 1),  0xbee8);
 277         Trio_WaitQueue(0x0400);
 278         outw(0xffff,  0xaae8);       /* Enable all planes */
 279         outw(0xffff, 0xaae8);       /* Enable all planes */
 280         outw( MF_PIX_CONTROL | MFA_SRC_FOREGR_MIX,  0xbee8);
 281 }
 282
 283 int __init s3trio_init(struct device_node *dp){
 284
 285     u_char bus, dev;
 286     unsigned int t32;
 287     unsigned short cmd;
 288
 289         pci_device_loc(dp,&bus,&dev);
 290                 pcibios_read_config_dword(bus, dev, PCI_VENDOR_ID, &t32);
 291                 if(t32 == (PCI_DEVICE_ID_S3_TRIO << 16) + PCI_VENDOR_ID_S3) {
 292                         pcibios_read_config_dword(bus, dev, PCI_BASE_ADDRESS_0, &t32);
 293                         pcibios_read_config_dword(bus, dev, PCI_BASE_ADDRESS_1, &t32);
 294                         pcibios_read_config_word(bus, dev, PCI_COMMAND,&cmd);
 295
 296                         pcibios_write_config_word(bus, dev, PCI_COMMAND, PCI_COMMAND_IO | PCI_COMMAND_MEMORY);
 297
 298                         pcibios_write_config_dword(bus, dev, PCI_BASE_ADDRESS_0,0xffffffff);
 299                         pcibios_read_config_dword(bus, dev, PCI_BASE_ADDRESS_0, &t32);
 300
 301 /* This is a gross hack as OF only maps enough memory for the framebuffer and
 302    we want to use MMIO too. We should find out which chunk of address space
 303    we can use here */
 304                         pcibios_write_config_dword(bus,dev,PCI_BASE_ADDRESS_0,0xc6000000);
 305
 306                         /* unlock s3 */
 307
 308                         outb(0x01, 0x3C3);
 309
 310                         outb(inb(0x03CC) | 1, 0x3c2);
 311
 312                         outw(IO_OUT16VAL(0x48, 0x38),0x03D4);
 313                         outw(IO_OUT16VAL(0xA0, 0x39),0x03D4);
 314                         outb(0x33,0x3d4);
 315                         outw(IO_OUT16VAL((inb(0x3d5) & ~(0x2 | 0x10 |  0x40)) |
 316                                           0x20, 0x33), 0x3d4);
 317
 318                         outw(IO_OUT16VAL(0x6, 0x8), 0x3c4);
 319
 320                         /* switch to MMIO only mode */
 321
 322                         outb(0x58, 0x3d4);
 323                         outw(IO_OUT16VAL(inb(0x3d5) | 3 | 0x10, 0x58), 0x3d4);
 324                         outw(IO_OUT16VAL(8, 0x53), 0x3d4);
 325
 326                         /* switch off I/O accesses */
 327
 328 #if 0
 329                         pcibios_write_config_word(bus, dev, PCI_COMMAND,
 330                                         PCI_COMMAND_IO | PCI_COMMAND_MEMORY);
 331 #endif
 332                         return 1;
 333                 }
 334
 335         return 0;
 336 }
 337
 338
 339     /*
 340      *  Initialisation
 341      *  We heavily rely on OF for the moment. This needs fixing.
 342      */
 343
 344 static void __init s3triofb_of_init(struct device_node *dp)
 345 {
 346     int i, *pp, len;
 347     unsigned long address, size;
 348     u_long *CursorBase;
 349
 350     strncat(s3trio_name, dp->name, sizeof(s3trio_name));
 351     s3trio_name[sizeof(s3trio_name)-1] = '\0';
 352     strcpy(fb_fix.id, s3trio_name);
 353
 354     if((pp = (int *)get_property(dp, "vendor-id", &len)) != NULL
 355         && *pp!=PCI_VENDOR_ID_S3) {
 356         printk("%s: can't find S3 Trio board\n", dp->full_name);
 357         return;
 358     }
 359
 360     if((pp = (int *)get_property(dp, "device-id", &len)) != NULL
 361         && *pp!=PCI_DEVICE_ID_S3_TRIO) {
 362         printk("%s: can't find S3 Trio board\n", dp->full_name);
 363         return;
 364     }
 365
 366     if ((pp = (int *)get_property(dp, "depth", &len)) != NULL
 367         && len == sizeof(int) && *pp != 8) {
 368         printk("%s: can't use depth = %d\n", dp->full_name, *pp);
 369         return;
 370     }
 371     if ((pp = (int *)get_property(dp, "width", &len)) != NULL
 372         && len == sizeof(int))
 373         fb_var.xres = fb_var.xres_virtual = *pp;
 374     if ((pp = (int *)get_property(dp, "height", &len)) != NULL
 375         && len == sizeof(int))
 376         fb_var.yres = fb_var.yres_virtual = *pp;
 377     if ((pp = (int *)get_property(dp, "linebytes", &len)) != NULL
 378         && len == sizeof(int))
 379         fb_fix.line_length = *pp;
 380     else
 381         fb_fix.line_length = fb_var.xres_virtual;
 382     fb_fix.smem_len = fb_fix.line_length*fb_var.yres;
 383
 384     address = 0xc6000000;
 385     size = 64*1024*1024;
 386     if (!request_mem_region(address, size, "S3triofb"))
 387         return;
 388
 389     s3trio_init(dp);
 390     s3trio_base = ioremap(address, size);
 391     fb_fix.smem_start = address;
 392     fb_fix.type = FB_TYPE_PACKED_PIXELS;
 393     fb_fix.type_aux = 0;
 394     fb_fix.accel = FB_ACCEL_S3_TRIO64;
 395     fb_fix.mmio_start = address+0x1000000;
 396     fb_fix.mmio_len = 0x1000000;
 397
 398     fb_fix.xpanstep = 1;
 399     fb_fix.ypanstep = 1;
 400
 401     s3trio_resetaccel();
 402
 403     mem_out8(0x30, s3trio_base+0x1008000 + 0x03D4);
 404     mem_out8(0x2d, s3trio_base+0x1008000 + 0x03D4);
 405     mem_out8(0x2e, s3trio_base+0x1008000 + 0x03D4);
 406
 407     mem_out8(0x50, s3trio_base+0x1008000 + 0x03D4);
 408
 409     /* disable HW cursor */
 410
 411     mem_out8(0x39, s3trio_base+0x1008000 + 0x03D4);
 412     mem_out8(0xa0, s3trio_base+0x1008000 + 0x03D5);
 413
 414     mem_out8(0x45, s3trio_base+0x1008000 + 0x03D4);
 415     mem_out8(0, s3trio_base+0x1008000 + 0x03D5);
 416
 417     mem_out8(0x4e, s3trio_base+0x1008000 + 0x03D4);
 418     mem_out8(0, s3trio_base+0x1008000 + 0x03D5);
 419
 420     mem_out8(0x4f, s3trio_base+0x1008000 + 0x03D4);
 421     mem_out8(0, s3trio_base+0x1008000 + 0x03D5);
 422
 423     /* init HW cursor */
 424
 425     CursorBase = (u_long *)(s3trio_base + 2*1024*1024 - 0x400);
 426         for (i = 0; i < 8; i++) {
 427                 *(CursorBase  +(i*4)) = 0xffffff00;
 428                 *(CursorBase+1+(i*4)) = 0xffff0000;
 429                 *(CursorBase+2+(i*4)) = 0xffff0000;
 430                 *(CursorBase+3+(i*4)) = 0xffff0000;
 431         }
 432         for (i = 8; i < 64; i++) {
 433                 *(CursorBase  +(i*4)) = 0xffff0000;
 434                 *(CursorBase+1+(i*4)) = 0xffff0000;
 435                 *(CursorBase+2+(i*4)) = 0xffff0000;
 436                 *(CursorBase+3+(i*4)) = 0xffff0000;
 437         }
 438
 439
 440     mem_out8(0x4c, s3trio_base+0x1008000 + 0x03D4);
 441     mem_out8(((2*1024 - 1)&0xf00)>>8, s3trio_base+0x1008000 + 0x03D5);
 442
 443     mem_out8(0x4d, s3trio_base+0x1008000 + 0x03D4);
 444     mem_out8((2*1024 - 1) & 0xff, s3trio_base+0x1008000 + 0x03D5);
 445
 446     mem_out8(0x45, s3trio_base+0x1008000 + 0x03D4);
 447     mem_in8(s3trio_base+0x1008000 + 0x03D4);
 448
 449     mem_out8(0x4a, s3trio_base+0x1008000 + 0x03D4);
 450     mem_out8(0x80, s3trio_base+0x1008000 + 0x03D5);
 451     mem_out8(0x80, s3trio_base+0x1008000 + 0x03D5);
 452     mem_out8(0x80, s3trio_base+0x1008000 + 0x03D5);
 453
 454     mem_out8(0x4b, s3trio_base+0x1008000 + 0x03D4);
 455     mem_out8(0x00, s3trio_base+0x1008000 + 0x03D5);
 456     mem_out8(0x00, s3trio_base+0x1008000 + 0x03D5);
 457     mem_out8(0x00, s3trio_base+0x1008000 + 0x03D5);
 458
 459     mem_out8(0x45, s3trio_base+0x1008000 + 0x03D4);
 460     mem_out8(0, s3trio_base+0x1008000 + 0x03D5);
 461
 462     /* setup default color table */
 463
 464         for(i = 0; i < 16; i++) {
 465                 int j = color_table[i];
 466                 palette[i].red=default_red[j];
 467                 palette[i].green=default_grn[j];
 468                 palette[i].blue=default_blu[j];
 469         }
 470
 471     s3trio_setcolreg(255, 56, 100, 160, 0, NULL /* not used */);
 472     s3trio_setcolreg(254, 0, 0, 0, 0, NULL /* not used */);
 473     memset((char *)s3trio_base, 0, 640*480);
 474
 475 #if 0
 476     Trio_RectFill(0, 0, 90, 90, 7, 1);
 477 #endif
 478
 479     fb_fix.visual = FB_VISUAL_PSEUDOCOLOR ;
 480     fb_var.xoffset = fb_var.yoffset = 0;
 481     fb_var.bits_per_pixel = 8;
 482     fb_var.grayscale = 0;
 483     fb_var.red.offset = fb_var.green.offset = fb_var.blue.offset = 0;
 484     fb_var.red.length = fb_var.green.length = fb_var.blue.length = 8;
 485     fb_var.red.msb_right = fb_var.green.msb_right = fb_var.blue.msb_right = 0;
 486     fb_var.transp.offset = fb_var.transp.length = fb_var.transp.msb_right = 0;
 487     fb_var.nonstd = 0;
 488     fb_var.activate = 0;
 489     fb_var.height = fb_var.width = -1;
 490     fb_var.accel_flags = FB_ACCELF_TEXT;
 491 #warning FIXME: always obey fb_var.accel_flags
 492     fb_var.pixclock = 1;
 493     fb_var.left_margin = fb_var.right_margin = 0;
 494     fb_var.upper_margin = fb_var.lower_margin = 0;
 495     fb_var.hsync_len = fb_var.vsync_len = 0;
 496     fb_var.sync = 0;
 497     fb_var.vmode = FB_VMODE_NONINTERLACED;
 498
 499     disp.var = fb_var;
 500     disp.cmap.start = 0;
 501     disp.cmap.len = 0;
 502     disp.cmap.red = disp.cmap.green = disp.cmap.blue = disp.cmap.transp = NULL;
 503     disp.visual = fb_fix.visual;
 504     disp.type = fb_fix.type;
 505     disp.type_aux = fb_fix.type_aux;
 506     disp.ypanstep = 0;
 507     disp.ywrapstep = 0;
 508     disp.line_length = fb_fix.line_length;
 509     disp.can_soft_blank = 1;
 510     disp.inverse = 0;
 511 #ifdef FBCON_HAS_CFB8
 512     if (fb_var.accel_flags & FB_ACCELF_TEXT)
 513         disp.dispsw = &fbcon_trio8;
 514     else
 515         disp.dispsw = &fbcon_cfb8;
 516 #else
 517     disp.dispsw = &fbcon_dummy;
 518 #endif
 519     disp.scrollmode = fb_var.accel_flags & FB_ACCELF_TEXT ? 0 : SCROLL_YREDRAW;
 520
 521     strcpy(fb_info.modename, "Trio64 ");
 522     strncat(fb_info.modename, dp->full_name, sizeof(fb_info.modename));
 523     fb_info.currcon = -1;
 524     fb_info.fbops = &s3trio_ops;
 525     fb_info.screen_base = s3trio_base;
 526 #if 0
 527     fb_info.fbvar_num = 1;
 528     fb_info.fbvar = &fb_var;
 529 #endif
 530     fb_info.disp = &disp;
 531     fb_info.fontname[0] = '\0';
 532     fb_info.changevar = NULL;
 533     fb_info.switch_con = &s3triofbcon_switch;
 534     fb_info.updatevar = &s3triofbcon_updatevar;
 535 #if 0
 536     fb_info.setcmap = &s3triofbcon_setcmap;
 537 #endif
 538
 539     fb_info.flags = FBINFO_FLAG_DEFAULT;
 540     if (register_framebuffer(&fb_info) < 0)
 541         return;
 542
 543     printk("fb%d: S3 Trio frame buffer device on %s\n",
 544            fb_info.node, dp->full_name);
 545 }
 546
 547
 548 static int s3triofbcon_switch(int con, struct fb_info *info)
 549 {
 550     /* Do we have to save the colormap? */
 551     if (fb_display[info->currcon].cmap.len)
 552         fb_get_cmap(&fb_display[info->currcon].cmap, 1, s3trio_getcolreg, info);
 553
 554     info->currcon = con;
 555     /* Install new colormap */
 556     do_install_cmap(con,info);
 557     return 0;
 558 }
 559
 560     /*
 561      *  Update the `var' structure (called by fbcon.c)
 562      */
 563
 564 static int s3triofbcon_updatevar(int con, struct fb_info *info)
 565 {
 566     /* Nothing */
 567     return 0;
 568 }
 569
 570     /*
 571      *  Blank the display.
 572      */
 573
 574 static int s3triofb_blank(int blank, struct fb_info *info)
 575 {
 576     unsigned char x;
 577
 578     mem_out8(0x1, s3trio_base+0x1008000 + 0x03c4);
 579     x = mem_in8(s3trio_base+0x1008000 + 0x03c5);
 580     mem_out8((x & (~0x20)) | (blank << 5), s3trio_base+0x1008000 + 0x03c5);
 581     return 0;
 582 }
 583
 584     /*
 585      *  Read a single color register and split it into
 586      *  colors/transparent. Return != 0 for invalid regno.
 587      */
 588
 589 static int s3trio_getcolreg(u_int regno, u_int *red, u_int *green, u_int *blue,
 590                          u_int *transp, struct fb_info *info)
 591 {
 592     if (regno > 255)
 593         return 1;
 594     *red = (palette[regno].red << 8) | palette[regno].red;
 595     *green = (palette[regno].green << 8) | palette[regno].green;
 596     *blue = (palette[regno].blue << 8) | palette[regno].blue;
 597     *transp = 0;
 598     return 0;
 599 }
 600
 601
 602     /*
 603      *  Set a single color register. Return != 0 for invalid regno.
 604      */
 605
 606 static int s3trio_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
 607                             u_int transp, struct fb_info *info)
 608 {
 609     if (regno > 255)
 610         return 1;
 611
 612     red >>= 8;
 613     green >>= 8;
 614     blue >>= 8;
 615     palette[regno].red = red;
 616     palette[regno].green = green;
 617     palette[regno].blue = blue;
 618
 619     mem_out8(regno,s3trio_base+0x1008000 + 0x3c8);
 620     mem_out8((red & 0xff) >> 2,s3trio_base+0x1008000 + 0x3c9);
 621     mem_out8((green & 0xff) >> 2,s3trio_base+0x1008000 + 0x3c9);
 622     mem_out8((blue & 0xff) >> 2,s3trio_base+0x1008000 + 0x3c9);
 623
 624     return 0;
 625 }
 626
 627 static void Trio_WaitQueue(u_short fifo) {
 628
 629         u_short status;
 630
 631         do
 632         {
 633                 status = mem_in16(s3trio_base + 0x1000000 + 0x9AE8);
 634         }  while (!(status & fifo));
 635
 636 }
 637
 638 static void Trio_WaitBlit(void) {
 639
 640         u_short status;
 641
 642         do
 643         {
 644                 status = mem_in16(s3trio_base + 0x1000000 + 0x9AE8);
 645         }  while (status & 0x200);
 646
 647 }
 648
 649 static void Trio_BitBLT(u_short curx, u_short cury, u_short destx,
 650                         u_short desty, u_short width, u_short height,
 651                         u_short mode) {
 652
 653         u_short blitcmd = 0xc011;
 654
 655         /* Set drawing direction */
 656         /* -Y, X maj, -X (default) */
 657
 658         if (curx > destx)
 659                 blitcmd |= 0x0020;  /* Drawing direction +X */
 660         else {
 661                 curx  += (width - 1);
 662                 destx += (width - 1);
 663         }
 664
 665         if (cury > desty)
 666                 blitcmd |= 0x0080;  /* Drawing direction +Y */
 667         else {
 668                 cury  += (height - 1);
 669                 desty += (height - 1);
 670         }
 671
 672         Trio_WaitQueue(0x0400);
 673
 674         outw(0xa000,  0xBEE8);
 675         outw(0x60 | mode,  0xBAE8);
 676
 677         outw(curx,  0x86E8);
 678         outw(cury,  0x82E8);
 679
 680         outw(destx,  0x8EE8);
 681         outw(desty,  0x8AE8);
 682
 683         outw(height - 1,  0xBEE8);
 684         outw(width - 1,  0x96E8);
 685
 686         outw(blitcmd,  0x9AE8);
 687
 688 }
 689
 690 static void Trio_RectFill(u_short x, u_short y, u_short width, u_short height,
 691                           u_short mode, u_short color) {
 692
 693         u_short blitcmd = 0x40b1;
 694
 695         Trio_WaitQueue(0x0400);
 696
 697         outw(0xa000,  0xBEE8);
 698         outw((0x20 | mode),  0xBAE8);
 699         outw(0xe000,  0xBEE8);
 700         outw(color,  0xA6E8);
 701         outw(x,  0x86E8);
 702         outw(y,  0x82E8);
 703         outw((height - 1), 0xBEE8);
 704         outw((width - 1), 0x96E8);
 705         outw(blitcmd,  0x9AE8);
 706
 707 }
 708
 709
 710 static void Trio_MoveCursor(u_short x, u_short y) {
 711
 712         mem_out8(0x39, s3trio_base + 0x1008000 + 0x3d4);
 713         mem_out8(0xa0, s3trio_base + 0x1008000 + 0x3d5);
 714
 715         mem_out8(0x46, s3trio_base + 0x1008000 + 0x3d4);
 716         mem_out8((x & 0x0700) >> 8, s3trio_base + 0x1008000 + 0x3d5);
 717         mem_out8(0x47, s3trio_base + 0x1008000 + 0x3d4);
 718         mem_out8(x & 0x00ff, s3trio_base + 0x1008000 + 0x3d5);
 719
 720         mem_out8(0x48, s3trio_base + 0x1008000 + 0x3d4);
 721         mem_out8((y & 0x0700) >> 8, s3trio_base + 0x1008000 + 0x3d5);
 722         mem_out8(0x49, s3trio_base + 0x1008000 + 0x3d4);
 723         mem_out8(y & 0x00ff, s3trio_base + 0x1008000 + 0x3d5);
 724
 725 }
 726
 727
 728     /*
 729      *  Text console acceleration
 730      */
 731
 732 #ifdef FBCON_HAS_CFB8
 733 static void fbcon_trio8_bmove(struct display *p, int sy, int sx, int dy,
 734                               int dx, int height, int width)
 735 {
 736     sx *= 8; dx *= 8; width *= 8;
 737     Trio_BitBLT((u_short)sx, (u_short)(sy*fontheight(p)), (u_short)dx,
 738                  (u_short)(dy*fontheight(p)), (u_short)width,
 739                  (u_short)(height*fontheight(p)), (u_short)S3_NEW);
 740 }
 741
 742 static void fbcon_trio8_clear(struct vc_data *conp, struct display *p, int sy,
 743                               int sx, int height, int width)
 744 {
 745     unsigned char bg;
 746
 747     sx *= 8; width *= 8;
 748     bg = attr_bgcol_ec(p,conp);
 749     Trio_RectFill((u_short)sx,
 750                    (u_short)(sy*fontheight(p)),
 751                    (u_short)width,
 752                    (u_short)(height*fontheight(p)),
 753                    (u_short)S3_NEW,
 754                    (u_short)bg);
 755 }
 756
 757 static void fbcon_trio8_putc(struct vc_data *conp, struct display *p, int c,
 758                              int yy, int xx)
 759 {
 760     Trio_WaitBlit();
 761     fbcon_cfb8_putc(conp, p, c, yy, xx);
 762 }
 763
 764 static void fbcon_trio8_putcs(struct vc_data *conp, struct display *p,
 765                               const unsigned short *s, int count, int yy, int xx)
 766 {
 767     Trio_WaitBlit();
 768     fbcon_cfb8_putcs(conp, p, s, count, yy, xx);
 769 }
 770
 771 static void fbcon_trio8_revc(struct display *p, int xx, int yy)
 772 {
 773     Trio_WaitBlit();
 774     fbcon_cfb8_revc(p, xx, yy);
 775 }
 776
 777 static struct display_switch fbcon_trio8 = {
 778    .setup =             fbcon_cfb8_setup,
 779    .bmove =             fbcon_trio8_bmove,
 780    .clear =             fbcon_trio8_clear,
 781    .putc =              fbcon_trio8_putc,
 782    .putcs =             fbcon_trio8_putcs,
 783    .revc =              fbcon_trio8_revc,
 784    .clear_margins =     fbcon_cfb8_clear_margins,
 785    .fontwidthmask =     FONTWIDTH(8)
 786 };
 787 #endif
 788
 789 MODULE_LICENSE("GPL");