| /* |
| * linux/drivers/video/S3Triofb.c -- Open Firmware based frame buffer device |
| * |
| * Copyright (C) 1997 Peter De Schrijver |
| * |
| * This driver is partly based on the PowerMac console driver: |
| * |
| * Copyright (C) 1996 Paul Mackerras |
| * |
| * and on the Open Firmware based frame buffer device: |
| * |
| * Copyright (C) 1997 Geert Uytterhoeven |
| * |
| * This file is subject to the terms and conditions of the GNU General Public |
| * License. See the file COPYING in the main directory of this archive for |
| * more details. |
| */ |
| |
| /* |
| Bugs : + This driver should be merged with the CyberVision driver. The |
| CyberVision is a Zorro III implementation of the S3Trio64 chip. |
| |
| */ |
| |
| #include <linux/config.h> |
| #include <linux/kernel.h> |
| #include <linux/module.h> |
| #include <linux/errno.h> |
| #include <linux/string.h> |
| #include <linux/mm.h> |
| #include <linux/tty.h> |
| #include <linux/slab.h> |
| #include <linux/vmalloc.h> |
| #include <linux/delay.h> |
| #include <linux/interrupt.h> |
| #include <linux/fb.h> |
| #include <linux/init.h> |
| #include <linux/selection.h> |
| #include <linux/pci.h> |
| #ifdef CONFIG_FB_COMPAT_XPMAC |
| #include <asm/vc_ioctl.h> |
| #endif |
| |
| #include <video/fbcon.h> |
| #include <video/fbcon-cfb8.h> |
| #include <video/s3blit.h> |
| |
| |
| #define mem_in8(addr) in_8((void *)(addr)) |
| #define mem_in16(addr) in_le16((void *)(addr)) |
| #define mem_in32(addr) in_le32((void *)(addr)) |
| |
| #define mem_out8(val, addr) out_8((void *)(addr), val) |
| #define mem_out16(val, addr) out_le16((void *)(addr), val) |
| #define mem_out32(val, addr) out_le32((void *)(addr), val) |
| |
| #define IO_OUT16VAL(v, r) (((v) << 8) | (r)) |
| |
| |
| static int currcon = 0; |
| static int disabled; |
| static struct display disp; |
| static struct fb_info fb_info; |
| static struct { u_char red, green, blue, pad; } palette[256]; |
| static char s3trio_name[16] = "S3Trio "; |
| static char *s3trio_base; |
| |
| static struct fb_fix_screeninfo fb_fix; |
| static struct fb_var_screeninfo S3triofb_default_var = { |
| 640, 480, 640, 480, 0, 0, 8, 0, |
| {0, 8, 0}, {0, 8, 0}, {0, 8, 0}, {0, 0, 0}, |
| 0, 0, -1, FB_ACCELF_TEXT, 39722, 40, 24, 32, 11, 96, 2, |
| FB_SYNC_COMP_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT, |
| FB_VMODE_NONINTERLACED |
| }; |
| static struct fb_var_screeninfo fb_var = { 0,}; |
| |
| /* |
| * Interface used by the world |
| */ |
| |
| static void __init s3triofb_pci_init(struct pci_dev *dp); |
| static int s3trio_get_fix(struct fb_fix_screeninfo *fix, int con, |
| struct fb_info *info); |
| static int s3trio_get_var(struct fb_var_screeninfo *var, int con, |
| struct fb_info *info); |
| static int s3trio_set_var(struct fb_var_screeninfo *var, int con, |
| struct fb_info *info); |
| static int s3trio_get_cmap(struct fb_cmap *cmap, int kspc, int con, |
| struct fb_info *info); |
| static int s3trio_set_cmap(struct fb_cmap *cmap, int kspc, int con, |
| struct fb_info *info); |
| static int s3trio_pan_display(struct fb_var_screeninfo *var, int con, |
| struct fb_info *info); |
| |
| |
| /* |
| * Interface to the low level console driver |
| */ |
| |
| int s3triofb_init(void); |
| static int s3triofbcon_switch(int con, struct fb_info *info); |
| static int s3triofbcon_updatevar(int con, struct fb_info *info); |
| static void s3triofbcon_blank(int blank, struct fb_info *info); |
| #if 0 |
| static int s3triofbcon_setcmap(struct fb_cmap *cmap, int con); |
| #endif |
| |
| /* |
| * Text console acceleration |
| */ |
| |
| #ifdef FBCON_HAS_CFB8 |
| static struct display_switch fbcon_trio8; |
| #endif |
| |
| /* |
| * Accelerated Functions used by the low level console driver |
| */ |
| |
| static void Trio_WaitQueue(u_short fifo); |
| static void Trio_WaitBlit(void); |
| static void Trio_BitBLT(u_short curx, u_short cury, u_short destx, |
| u_short desty, u_short width, u_short height, |
| u_short mode); |
| static void Trio_RectFill(u_short x, u_short y, u_short width, u_short height, |
| u_short mode, u_short color); |
| static void Trio_MoveCursor(u_short x, u_short y); |
| |
| |
| /* |
| * Internal routines |
| */ |
| |
| static int s3trio_getcolreg(u_int regno, u_int *red, u_int *green, u_int *blue, |
| u_int *transp, struct fb_info *info); |
| static int s3trio_setcolreg(u_int regno, u_int red, u_int green, u_int blue, |
| u_int transp, struct fb_info *info); |
| static void do_install_cmap(int con, struct fb_info *info); |
| |
| |
| static struct fb_ops s3trio_ops = { |
| owner: THIS_MODULE, |
| fb_get_fix: s3trio_get_fix, |
| fb_get_var: s3trio_get_var, |
| fb_set_var: s3trio_set_var, |
| fb_get_cmap: s3trio_get_cmap, |
| fb_set_cmap: s3trio_set_cmap, |
| fb_pan_display: s3trio_pan_display, |
| }; |
| |
| /* |
| * Get the Fixed Part of the Display |
| */ |
| |
| static int s3trio_get_fix(struct fb_fix_screeninfo *fix, int con, |
| struct fb_info *info) |
| { |
| memcpy(fix, &fb_fix, sizeof(fb_fix)); |
| return 0; |
| } |
| |
| |
| /* |
| * Get the User Defined Part of the Display |
| */ |
| |
| static int s3trio_get_var(struct fb_var_screeninfo *var, int con, |
| struct fb_info *info) |
| { |
| memcpy(var, &fb_var, sizeof(fb_var)); |
| return 0; |
| } |
| |
| |
| /* |
| * Set the User Defined Part of the Display |
| */ |
| |
| static int s3trio_set_var(struct fb_var_screeninfo *var, int con, |
| struct fb_info *info) |
| { |
| if (var->xres > fb_var.xres || var->yres > fb_var.yres || |
| var->bits_per_pixel > fb_var.bits_per_pixel ) |
| /* || var->nonstd || var->vmode != FB_VMODE_NONINTERLACED) */ |
| return -EINVAL; |
| if (var->xres_virtual > fb_var.xres_virtual) { |
| outw(IO_OUT16VAL((var->xres_virtual /8) & 0xff, 0x13), 0x3d4); |
| outw(IO_OUT16VAL(((var->xres_virtual /8 ) & 0x300) >> 3, 0x51), 0x3d4); |
| fb_var.xres_virtual = var->xres_virtual; |
| fb_fix.line_length = var->xres_virtual; |
| } |
| fb_var.yres_virtual = var->yres_virtual; |
| memcpy(var, &fb_var, sizeof(fb_var)); |
| return 0; |
| } |
| |
| |
| /* |
| * Pan or Wrap the Display |
| * |
| * This call looks only at xoffset, yoffset and the FB_VMODE_YWRAP flag |
| */ |
| |
| static int s3trio_pan_display(struct fb_var_screeninfo *var, int con, |
| struct fb_info *info) |
| { |
| unsigned int base; |
| |
| if (var->xoffset > (var->xres_virtual - var->xres)) |
| return -EINVAL; |
| if (var->yoffset > (var->yres_virtual - var->yres)) |
| return -EINVAL; |
| |
| fb_var.xoffset = var->xoffset; |
| fb_var.yoffset = var->yoffset; |
| |
| base = var->yoffset * fb_fix.line_length + var->xoffset; |
| |
| outw(IO_OUT16VAL((base >> 8) & 0xff, 0x0c),0x03D4); |
| outw(IO_OUT16VAL(base & 0xff, 0x0d),0x03D4); |
| outw(IO_OUT16VAL((base >> 16) & 0xf, 0x69),0x03D4); |
| return 0; |
| } |
| |
| |
| /* |
| * Get the Colormap |
| */ |
| |
| static int s3trio_get_cmap(struct fb_cmap *cmap, int kspc, int con, |
| struct fb_info *info) |
| { |
| if (con == currcon) /* current console? */ |
| return fb_get_cmap(cmap, kspc, s3trio_getcolreg, info); |
| else if (fb_display[con].cmap.len) /* non default colormap? */ |
| fb_copy_cmap(&fb_display[con].cmap, cmap, kspc ? 0 : 2); |
| else |
| fb_copy_cmap(fb_default_cmap(1 << fb_display[con].var.bits_per_pixel), |
| cmap, kspc ? 0 : 2); |
| return 0; |
| } |
| |
| /* |
| * Set the Colormap |
| */ |
| |
| static int s3trio_set_cmap(struct fb_cmap *cmap, int kspc, int con, |
| struct fb_info *info) |
| { |
| int err; |
| |
| |
| if (!fb_display[con].cmap.len) { /* no colormap allocated? */ |
| if ((err = fb_alloc_cmap(&fb_display[con].cmap, |
| 1<<fb_display[con].var.bits_per_pixel, 0))) |
| return err; |
| } |
| if (con == currcon) /* current console? */ |
| return fb_set_cmap(cmap, kspc, s3trio_setcolreg, info); |
| else |
| fb_copy_cmap(cmap, &fb_display[con].cmap, kspc ? 0 : 1); |
| return 0; |
| } |
| |
| int __init s3triofb_setup(char *options) { |
| char *this_opt; |
| |
| if (!options || !*options) |
| return 0; |
| |
| while ((this_opt = strsep(&options, ",")) != NULL) { |
| if (!*this_opt) |
| continue; |
| |
| if (!strcmp(this_opt, "disabled")) |
| disabled = 1; |
| } |
| return 0; |
| } |
| |
| int __init s3triofb_init(void) |
| { |
| struct pci_dev *dp = NULL; |
| |
| if (disabled) |
| return -ENXIO; |
| |
| dp = pci_find_device(PCI_VENDOR_ID_S3, PCI_DEVICE_ID_S3_TRIO, dp); |
| if ((dp != 0) && ((dp->class >> 16) == PCI_BASE_CLASS_DISPLAY)) { |
| s3triofb_pci_init(dp); |
| return 0; |
| } else |
| return -ENODEV; |
| } |
| |
| static void __exit s3triofb_exit(void) |
| { |
| unregister_framebuffer(&fb_info); |
| iounmap(s3trio_base); |
| /* XXX unshare VGA regions */ |
| } |
| |
| void __init s3trio_resetaccel(void){ |
| |
| |
| #define EC01_ENH_ENB 0x0005 |
| #define EC01_LAW_ENB 0x0010 |
| #define EC01_MMIO_ENB 0x0020 |
| |
| #define EC00_RESET 0x8000 |
| #define EC00_ENABLE 0x4000 |
| #define MF_MULT_MISC 0xE000 |
| #define SRC_FOREGROUND 0x0020 |
| #define SRC_BACKGROUND 0x0000 |
| #define MIX_SRC 0x0007 |
| #define MF_T_CLIP 0x1000 |
| #define MF_L_CLIP 0x2000 |
| #define MF_B_CLIP 0x3000 |
| #define MF_R_CLIP 0x4000 |
| #define MF_PIX_CONTROL 0xA000 |
| #define MFA_SRC_FOREGR_MIX 0x0000 |
| #define MF_PIX_CONTROL 0xA000 |
| |
| outw(EC00_RESET, 0x42e8); |
| inw( 0x42e8); |
| outw(EC00_ENABLE, 0x42e8); |
| inw( 0x42e8); |
| outw(EC01_ENH_ENB | EC01_LAW_ENB, |
| 0x4ae8); |
| outw(MF_MULT_MISC, 0xbee8); /* 16 bit I/O registers */ |
| |
| /* Now set some basic accelerator registers */ |
| Trio_WaitQueue(0x0400); |
| outw(SRC_FOREGROUND | MIX_SRC, 0xbae8); |
| outw(SRC_BACKGROUND | MIX_SRC, 0xb6e8);/* direct color*/ |
| outw(MF_T_CLIP | 0, 0xbee8 ); /* clip virtual area */ |
| outw(MF_L_CLIP | 0, 0xbee8 ); |
| outw(MF_R_CLIP | (640 - 1), 0xbee8); |
| outw(MF_B_CLIP | (480 - 1), 0xbee8); |
| Trio_WaitQueue(0x0400); |
| outw(0xffff, 0xaae8); /* Enable all planes */ |
| outw(0xffff, 0xaae8); /* Enable all planes */ |
| outw( MF_PIX_CONTROL | MFA_SRC_FOREGR_MIX, 0xbee8); |
| } |
| |
| int __init s3trio_init(struct pci_dev *dp) |
| { |
| /* unlock s3 */ |
| outb(0x01, 0x3C3); |
| outb(inb(0x03CC) | 1, 0x3c2); |
| outw(IO_OUT16VAL(0x48, 0x38),0x03D4); |
| outw(IO_OUT16VAL(0xA0, 0x39),0x03D4); |
| outb(0x33,0x3d4); |
| outw(IO_OUT16VAL((inb(0x3d5) & ~(0x2 | 0x10 | 0x40)) | |
| 0x20, 0x33), 0x3d4); |
| |
| outw(IO_OUT16VAL(0x6, 0x8), 0x3c4); |
| printk("S3trio: unlocked s3\n"); |
| |
| /* switch to MMIO only mode */ |
| outb(0x58, 0x3d4); |
| outw(IO_OUT16VAL(inb(0x3d5) | 3 | 0x10, 0x58), 0x3d4); |
| outw(IO_OUT16VAL(8, 0x53), 0x3d4); |
| printk("S3trio: switched to mmio only mode\n"); |
| |
| return 1; |
| } |
| |
| |
| /* |
| * Initialisation |
| */ |
| |
| static void __init s3triofb_pci_init(struct pci_dev *dp) |
| { |
| int i; |
| unsigned long address, size; |
| u_long *CursorBase; |
| u16 cmd; |
| |
| strcpy(fb_fix.id, s3trio_name); |
| |
| fb_var = S3triofb_default_var; |
| fb_fix.line_length = fb_var.xres_virtual; |
| fb_fix.smem_len = fb_fix.line_length*fb_var.yres; |
| |
| /* This driver cannot cope if the firmware has not initialised the |
| * device. So, if the device isn't enabled we simply return |
| */ |
| pci_read_config_word(dp, PCI_COMMAND, &cmd); |
| if (!(cmd & PCI_COMMAND_MEMORY)) { |
| printk(KERN_NOTICE "S3trio: card was not initialised by firmware\n"); |
| return; |
| } |
| |
| /* Enable it anyway */ |
| if (pci_enable_device(dp)) { |
| printk(KERN_ERR "S3trio: failed to enable PCI device\n"); |
| return; |
| } |
| |
| /* There is only one memory region and it covers the mmio and fb areas */ |
| address = pci_resource_start(dp, 0); |
| size = pci_resource_len(dp, 0); /* size = 64*1024*1024; */ |
| if (!request_mem_region(address, size, "S3triofb")) { |
| printk("S3trio: failed to allocate memory region\n"); |
| return; |
| } |
| |
| s3trio_init(dp); |
| s3trio_base = ioremap(address, size); |
| fb_fix.smem_start = address; |
| fb_fix.type = FB_TYPE_PACKED_PIXELS; |
| fb_fix.type_aux = 0; |
| fb_fix.accel = FB_ACCEL_S3_TRIO64; |
| fb_fix.mmio_start = address+0x1000000; |
| fb_fix.mmio_len = 0x1000000; |
| |
| fb_fix.xpanstep = 1; |
| fb_fix.ypanstep = 1; |
| |
| s3trio_resetaccel(); |
| |
| mem_out8(0x30, s3trio_base+0x1008000 + 0x03D4); |
| mem_out8(0x2d, s3trio_base+0x1008000 + 0x03D4); |
| mem_out8(0x2e, s3trio_base+0x1008000 + 0x03D4); |
| |
| mem_out8(0x50, s3trio_base+0x1008000 + 0x03D4); |
| |
| /* disable HW cursor */ |
| |
| mem_out8(0x39, s3trio_base+0x1008000 + 0x03D4); |
| mem_out8(0xa0, s3trio_base+0x1008000 + 0x03D5); |
| |
| mem_out8(0x45, s3trio_base+0x1008000 + 0x03D4); |
| mem_out8(0, s3trio_base+0x1008000 + 0x03D5); |
| |
| mem_out8(0x4e, s3trio_base+0x1008000 + 0x03D4); |
| mem_out8(0, s3trio_base+0x1008000 + 0x03D5); |
| |
| mem_out8(0x4f, s3trio_base+0x1008000 + 0x03D4); |
| mem_out8(0, s3trio_base+0x1008000 + 0x03D5); |
| |
| /* init HW cursor */ |
| |
| CursorBase = (u_long *)(s3trio_base + 2*1024*1024 - 0x400); |
| for (i = 0; i < 8; i++) { |
| *(CursorBase +(i*4)) = 0xffffff00; |
| *(CursorBase+1+(i*4)) = 0xffff0000; |
| *(CursorBase+2+(i*4)) = 0xffff0000; |
| *(CursorBase+3+(i*4)) = 0xffff0000; |
| } |
| for (i = 8; i < 64; i++) { |
| *(CursorBase +(i*4)) = 0xffff0000; |
| *(CursorBase+1+(i*4)) = 0xffff0000; |
| *(CursorBase+2+(i*4)) = 0xffff0000; |
| *(CursorBase+3+(i*4)) = 0xffff0000; |
| } |
| |
| |
| mem_out8(0x4c, s3trio_base+0x1008000 + 0x03D4); |
| mem_out8(((2*1024 - 1)&0xf00)>>8, s3trio_base+0x1008000 + 0x03D5); |
| |
| mem_out8(0x4d, s3trio_base+0x1008000 + 0x03D4); |
| mem_out8((2*1024 - 1) & 0xff, s3trio_base+0x1008000 + 0x03D5); |
| |
| mem_out8(0x45, s3trio_base+0x1008000 + 0x03D4); |
| mem_in8(s3trio_base+0x1008000 + 0x03D4); |
| |
| mem_out8(0x4a, s3trio_base+0x1008000 + 0x03D4); |
| mem_out8(0x80, s3trio_base+0x1008000 + 0x03D5); |
| mem_out8(0x80, s3trio_base+0x1008000 + 0x03D5); |
| mem_out8(0x80, s3trio_base+0x1008000 + 0x03D5); |
| |
| mem_out8(0x4b, s3trio_base+0x1008000 + 0x03D4); |
| mem_out8(0x00, s3trio_base+0x1008000 + 0x03D5); |
| mem_out8(0x00, s3trio_base+0x1008000 + 0x03D5); |
| mem_out8(0x00, s3trio_base+0x1008000 + 0x03D5); |
| |
| mem_out8(0x45, s3trio_base+0x1008000 + 0x03D4); |
| mem_out8(0, s3trio_base+0x1008000 + 0x03D5); |
| |
| /* setup default color table */ |
| |
| for(i = 0; i < 16; i++) { |
| int j = color_table[i]; |
| palette[i].red=default_red[j]; |
| palette[i].green=default_grn[j]; |
| palette[i].blue=default_blu[j]; |
| } |
| |
| s3trio_setcolreg(255, 56, 100, 160, 0, NULL /* not used */); |
| s3trio_setcolreg(254, 0, 0, 0, 0, NULL /* not used */); |
| memset((char *)s3trio_base, 0, 640*480); |
| |
| #if 0 |
| Trio_RectFill(0, 0, 90, 90, 7, 1); |
| #endif |
| |
| fb_fix.visual = FB_VISUAL_PSEUDOCOLOR ; |
| fb_var.xoffset = fb_var.yoffset = 0; |
| fb_var.bits_per_pixel = 8; |
| fb_var.grayscale = 0; |
| fb_var.red.offset = fb_var.green.offset = fb_var.blue.offset = 0; |
| fb_var.red.length = fb_var.green.length = fb_var.blue.length = 8; |
| fb_var.red.msb_right = fb_var.green.msb_right = fb_var.blue.msb_right = 0; |
| fb_var.transp.offset = fb_var.transp.length = fb_var.transp.msb_right = 0; |
| fb_var.nonstd = 0; |
| fb_var.activate = 0; |
| fb_var.height = fb_var.width = -1; |
| fb_var.accel_flags = FB_ACCELF_TEXT; |
| #warning FIXME: always obey fb_var.accel_flags |
| fb_var.pixclock = 1; |
| fb_var.left_margin = fb_var.right_margin = 0; |
| fb_var.upper_margin = fb_var.lower_margin = 0; |
| fb_var.hsync_len = fb_var.vsync_len = 0; |
| fb_var.sync = 0; |
| fb_var.vmode = FB_VMODE_NONINTERLACED; |
| |
| disp.var = fb_var; |
| disp.cmap.start = 0; |
| disp.cmap.len = 0; |
| disp.cmap.red = disp.cmap.green = disp.cmap.blue = disp.cmap.transp = NULL; |
| disp.screen_base = s3trio_base; |
| disp.visual = fb_fix.visual; |
| disp.type = fb_fix.type; |
| disp.type_aux = fb_fix.type_aux; |
| disp.ypanstep = 0; |
| disp.ywrapstep = 0; |
| disp.line_length = fb_fix.line_length; |
| disp.can_soft_blank = 1; |
| disp.inverse = 0; |
| #ifdef FBCON_HAS_CFB8 |
| if (fb_var.accel_flags & FB_ACCELF_TEXT) |
| disp.dispsw = &fbcon_trio8; |
| else |
| disp.dispsw = &fbcon_cfb8; |
| #else |
| disp.dispsw = &fbcon_dummy; |
| #endif |
| disp.scrollmode = fb_var.accel_flags & FB_ACCELF_TEXT ? 0 : SCROLL_YREDRAW; |
| |
| strcpy(fb_info.modename, "Trio64"); |
| fb_info.node = -1; |
| fb_info.fbops = &s3trio_ops; |
| #if 0 |
| fb_info.fbvar_num = 1; |
| fb_info.fbvar = &fb_var; |
| #endif |
| fb_info.disp = &disp; |
| fb_info.fontname[0] = '\0'; |
| fb_info.changevar = NULL; |
| fb_info.switch_con = &s3triofbcon_switch; |
| fb_info.updatevar = &s3triofbcon_updatevar; |
| fb_info.blank = &s3triofbcon_blank; |
| #if 0 |
| fb_info.setcmap = &s3triofbcon_setcmap; |
| #endif |
| |
| #ifdef CONFIG_FB_COMPAT_XPMAC |
| if (!console_fb_info) { |
| display_info.height = fb_var.yres; |
| display_info.width = fb_var.xres; |
| display_info.depth = 8; |
| display_info.pitch = fb_fix.line_length; |
| display_info.mode = 0; |
| strncpy(display_info.name, dp->name, sizeof(display_info.name)); |
| display_info.fb_address = (unsigned long)fb_fix.smem_start; |
| display_info.disp_reg_address = address + 0x1008000; |
| display_info.cmap_adr_address = address + 0x1008000 + 0x3c8; |
| display_info.cmap_data_address = address + 0x1008000 + 0x3c9; |
| console_fb_info = &fb_info; |
| } |
| #endif /* CONFIG_FB_COMPAT_XPMAC) */ |
| |
| fb_info.flags = FBINFO_FLAG_DEFAULT; |
| if (register_framebuffer(&fb_info) < 0) |
| return; |
| |
| printk("fb%d: S3 Trio frame buffer device on %s\n", |
| GET_FB_IDX(fb_info.node), dp->name); |
| } |
| |
| |
| static int s3triofbcon_switch(int con, struct fb_info *info) |
| { |
| /* Do we have to save the colormap? */ |
| if (fb_display[currcon].cmap.len) |
| fb_get_cmap(&fb_display[currcon].cmap, 1, s3trio_getcolreg, info); |
| |
| currcon = con; |
| /* Install new colormap */ |
| do_install_cmap(con,info); |
| return 0; |
| } |
| |
| /* |
| * Update the `var' structure (called by fbcon.c) |
| */ |
| |
| static int s3triofbcon_updatevar(int con, struct fb_info *info) |
| { |
| /* Nothing */ |
| return 0; |
| } |
| |
| /* |
| * Blank the display. |
| */ |
| |
| static void s3triofbcon_blank(int blank, struct fb_info *info) |
| { |
| unsigned char x; |
| |
| mem_out8(0x1, s3trio_base+0x1008000 + 0x03c4); |
| x = mem_in8(s3trio_base+0x1008000 + 0x03c5); |
| mem_out8((x & (~0x20)) | (blank << 5), s3trio_base+0x1008000 + 0x03c5); |
| } |
| |
| /* |
| * Set the colormap |
| */ |
| |
| #if 0 |
| static int s3triofbcon_setcmap(struct fb_cmap *cmap, int con) |
| { |
| return(s3trio_set_cmap(cmap, 1, con, &fb_info)); |
| } |
| #endif |
| |
| |
| /* |
| * Read a single color register and split it into |
| * colors/transparent. Return != 0 for invalid regno. |
| */ |
| |
| static int s3trio_getcolreg(u_int regno, u_int *red, u_int *green, u_int *blue, |
| u_int *transp, struct fb_info *info) |
| { |
| if (regno > 255) |
| return 1; |
| *red = (palette[regno].red << 8) | palette[regno].red; |
| *green = (palette[regno].green << 8) | palette[regno].green; |
| *blue = (palette[regno].blue << 8) | palette[regno].blue; |
| *transp = 0; |
| return 0; |
| } |
| |
| |
| /* |
| * Set a single color register. Return != 0 for invalid regno. |
| */ |
| |
| static int s3trio_setcolreg(u_int regno, u_int red, u_int green, u_int blue, |
| u_int transp, struct fb_info *info) |
| { |
| if (regno > 255) |
| return 1; |
| |
| red >>= 8; |
| green >>= 8; |
| blue >>= 8; |
| palette[regno].red = red; |
| palette[regno].green = green; |
| palette[regno].blue = blue; |
| |
| mem_out8(regno,s3trio_base+0x1008000 + 0x3c8); |
| mem_out8((red & 0xff) >> 2,s3trio_base+0x1008000 + 0x3c9); |
| mem_out8((green & 0xff) >> 2,s3trio_base+0x1008000 + 0x3c9); |
| mem_out8((blue & 0xff) >> 2,s3trio_base+0x1008000 + 0x3c9); |
| |
| return 0; |
| } |
| |
| |
| static void do_install_cmap(int con, struct fb_info *info) |
| { |
| if (con != currcon) |
| return; |
| if (fb_display[con].cmap.len) |
| fb_set_cmap(&fb_display[con].cmap, 1, s3trio_setcolreg, &fb_info); |
| else |
| fb_set_cmap(fb_default_cmap(fb_display[con].var.bits_per_pixel), 1, |
| s3trio_setcolreg, &fb_info); |
| } |
| |
| static void Trio_WaitQueue(u_short fifo) { |
| |
| u_short status; |
| |
| do |
| { |
| status = mem_in16(s3trio_base + 0x1000000 + 0x9AE8); |
| } while (!(status & fifo)); |
| |
| } |
| |
| static void Trio_WaitBlit(void) { |
| |
| u_short status; |
| |
| do |
| { |
| status = mem_in16(s3trio_base + 0x1000000 + 0x9AE8); |
| } while (status & 0x200); |
| |
| } |
| |
| static void Trio_BitBLT(u_short curx, u_short cury, u_short destx, |
| u_short desty, u_short width, u_short height, |
| u_short mode) { |
| |
| u_short blitcmd = 0xc011; |
| |
| /* Set drawing direction */ |
| /* -Y, X maj, -X (default) */ |
| |
| if (curx > destx) |
| blitcmd |= 0x0020; /* Drawing direction +X */ |
| else { |
| curx += (width - 1); |
| destx += (width - 1); |
| } |
| |
| if (cury > desty) |
| blitcmd |= 0x0080; /* Drawing direction +Y */ |
| else { |
| cury += (height - 1); |
| desty += (height - 1); |
| } |
| |
| Trio_WaitQueue(0x0400); |
| |
| outw(0xa000, 0xBEE8); |
| outw(0x60 | mode, 0xBAE8); |
| |
| outw(curx, 0x86E8); |
| outw(cury, 0x82E8); |
| |
| outw(destx, 0x8EE8); |
| outw(desty, 0x8AE8); |
| |
| outw(height - 1, 0xBEE8); |
| outw(width - 1, 0x96E8); |
| |
| outw(blitcmd, 0x9AE8); |
| |
| } |
| |
| static void Trio_RectFill(u_short x, u_short y, u_short width, u_short height, |
| u_short mode, u_short color) { |
| |
| u_short blitcmd = 0x40b1; |
| |
| Trio_WaitQueue(0x0400); |
| |
| outw(0xa000, 0xBEE8); |
| outw((0x20 | mode), 0xBAE8); |
| outw(0xe000, 0xBEE8); |
| outw(color, 0xA6E8); |
| outw(x, 0x86E8); |
| outw(y, 0x82E8); |
| outw((height - 1), 0xBEE8); |
| outw((width - 1), 0x96E8); |
| outw(blitcmd, 0x9AE8); |
| |
| } |
| |
| |
| static void Trio_MoveCursor(u_short x, u_short y) { |
| |
| mem_out8(0x39, s3trio_base + 0x1008000 + 0x3d4); |
| mem_out8(0xa0, s3trio_base + 0x1008000 + 0x3d5); |
| |
| mem_out8(0x46, s3trio_base + 0x1008000 + 0x3d4); |
| mem_out8((x & 0x0700) >> 8, s3trio_base + 0x1008000 + 0x3d5); |
| mem_out8(0x47, s3trio_base + 0x1008000 + 0x3d4); |
| mem_out8(x & 0x00ff, s3trio_base + 0x1008000 + 0x3d5); |
| |
| mem_out8(0x48, s3trio_base + 0x1008000 + 0x3d4); |
| mem_out8((y & 0x0700) >> 8, s3trio_base + 0x1008000 + 0x3d5); |
| mem_out8(0x49, s3trio_base + 0x1008000 + 0x3d4); |
| mem_out8(y & 0x00ff, s3trio_base + 0x1008000 + 0x3d5); |
| |
| } |
| |
| |
| /* |
| * Text console acceleration |
| */ |
| |
| #ifdef FBCON_HAS_CFB8 |
| static void fbcon_trio8_bmove(struct display *p, int sy, int sx, int dy, |
| int dx, int height, int width) |
| { |
| sx *= 8; dx *= 8; width *= 8; |
| Trio_BitBLT((u_short)sx, (u_short)(sy*fontheight(p)), (u_short)dx, |
| (u_short)(dy*fontheight(p)), (u_short)width, |
| (u_short)(height*fontheight(p)), (u_short)S3_NEW); |
| } |
| |
| static void fbcon_trio8_clear(struct vc_data *conp, struct display *p, int sy, |
| int sx, int height, int width) |
| { |
| unsigned char bg; |
| |
| sx *= 8; width *= 8; |
| bg = attr_bgcol_ec(p,conp); |
| Trio_RectFill((u_short)sx, |
| (u_short)(sy*fontheight(p)), |
| (u_short)width, |
| (u_short)(height*fontheight(p)), |
| (u_short)S3_NEW, |
| (u_short)bg); |
| } |
| |
| static void fbcon_trio8_putc(struct vc_data *conp, struct display *p, int c, |
| int yy, int xx) |
| { |
| Trio_WaitBlit(); |
| fbcon_cfb8_putc(conp, p, c, yy, xx); |
| } |
| |
| static void fbcon_trio8_putcs(struct vc_data *conp, struct display *p, |
| const unsigned short *s, int count, int yy, int xx) |
| { |
| Trio_WaitBlit(); |
| fbcon_cfb8_putcs(conp, p, s, count, yy, xx); |
| } |
| |
| static void fbcon_trio8_revc(struct display *p, int xx, int yy) |
| { |
| Trio_WaitBlit(); |
| fbcon_cfb8_revc(p, xx, yy); |
| } |
| |
| static struct display_switch fbcon_trio8 = { |
| setup: fbcon_cfb8_setup, |
| bmove: fbcon_trio8_bmove, |
| clear: fbcon_trio8_clear, |
| putc: fbcon_trio8_putc, |
| putcs: fbcon_trio8_putcs, |
| revc: fbcon_trio8_revc, |
| clear_margins: fbcon_cfb8_clear_margins, |
| fontwidthmask: FONTWIDTH(8) |
| }; |
| #endif |
| |
| #ifdef MODULE |
| module_init(s3triofb_init); |
| MODULE_LICENSE("GPL"); |
| #endif |
| module_exit(s3triofb_exit); |