| /* |
| * drivers/video/tx3912fb.c |
| * |
| * Copyright (C) 1999 Harald Koerfgen |
| * Copyright (C) 2001 Steven Hill (sjhill@realitydiluted.com) |
| * |
| * 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. |
| * |
| * Framebuffer for LCD controller in TMPR3912/05 and PR31700 processors |
| */ |
| #include <linux/config.h> |
| #include <linux/module.h> |
| #include <linux/kernel.h> |
| #include <linux/errno.h> |
| #include <linux/string.h> |
| #include <linux/tty.h> |
| #include <linux/delay.h> |
| #include <linux/interrupt.h> |
| #include <linux/init.h> |
| #include <linux/pm.h> |
| #include <linux/fb.h> |
| #include <video/fbcon.h> |
| #include <video/fbcon-mfb.h> |
| #include <video/fbcon-cfb2.h> |
| #include <video/fbcon-cfb4.h> |
| #include <video/fbcon-cfb8.h> |
| #include <asm/io.h> |
| #include <asm/bootinfo.h> |
| #include <asm/uaccess.h> |
| #include <asm/tx3912.h> |
| #include "tx3912fb.h" |
| |
| /* |
| * Frame buffer, palette and console structures |
| */ |
| static struct fb_info fb_info; |
| static struct { u_char red, green, blue, pad; } palette[256]; |
| #ifdef FBCON_HAS_CFB8 |
| static union { u16 cfb8[16]; } fbcon_cmap; |
| #endif |
| static struct display global_disp; |
| static int currcon = 0; |
| |
| /* |
| * Interface used by the world |
| */ |
| static int tx3912fb_get_fix(struct fb_fix_screeninfo *fix, int con, |
| struct fb_info *info); |
| static int tx3912fb_get_var(struct fb_var_screeninfo *var, int con, |
| struct fb_info *info); |
| static int tx3912fb_set_var(struct fb_var_screeninfo *var, int con, |
| struct fb_info *info); |
| static int tx3912fb_get_cmap(struct fb_cmap *cmap, int kspc, int con, |
| struct fb_info *info); |
| static int tx3912fb_set_cmap(struct fb_cmap *cmap, int kspc, int con, |
| struct fb_info *info); |
| static int tx3912fb_ioctl(struct inode *inode, struct file *file, u_int cmd, |
| u_long arg, int con, struct fb_info *info); |
| |
| /* |
| * Interface used by console driver |
| */ |
| int tx3912fb_init(void); |
| static int tx3912fbcon_switch(int con, struct fb_info *info); |
| static int tx3912fbcon_updatevar(int con, struct fb_info *info); |
| static void tx3912fbcon_blank(int blank, struct fb_info *info); |
| |
| /* |
| * Macros |
| */ |
| #define get_line_length(xres_virtual, bpp) \ |
| (u_long) (((int) xres_virtual * (int) bpp + 7) >> 3) |
| |
| /* |
| * Internal routines |
| */ |
| static int tx3912fb_getcolreg(u_int regno, u_int *red, u_int *green, |
| u_int *blue, u_int *transp, struct fb_info *info); |
| static int tx3912fb_setcolreg(u_int regno, u_int red, u_int green, u_int blue, |
| u_int transp, struct fb_info *info); |
| static void tx3912fb_install_cmap(int con, struct fb_info *info); |
| |
| |
| /* |
| * Frame buffer operations structure used by console driver |
| */ |
| static struct fb_ops tx3912fb_ops = { |
| owner: THIS_MODULE, |
| fb_get_fix: tx3912fb_get_fix, |
| fb_get_var: tx3912fb_get_var, |
| fb_set_var: tx3912fb_set_var, |
| fb_get_cmap: tx3912fb_get_cmap, |
| fb_set_cmap: tx3912fb_set_cmap, |
| fb_ioctl: tx3912fb_ioctl, |
| }; |
| |
| |
| /* |
| * Get fixed display data |
| */ |
| static int tx3912fb_get_fix(struct fb_fix_screeninfo *fix, int con, |
| struct fb_info *info) |
| { |
| struct display *display; |
| |
| memset(fix, 0, sizeof(struct fb_fix_screeninfo)); |
| strcpy(fix->id, TX3912FB_NAME); |
| |
| if (con == -1) |
| display = &global_disp; |
| else |
| display = &fb_display[con]; |
| |
| fix->smem_start = tx3912fb_vaddr; |
| fix->smem_len = tx3912fb_size; |
| fix->type = display->type; |
| fix->type_aux = display->type_aux; |
| fix->xpanstep = 0; |
| fix->ypanstep = display->ypanstep; |
| fix->ywrapstep = display->ywrapstep; |
| fix->visual = display->visual; |
| fix->line_length = display->line_length; |
| fix->accel = FB_ACCEL_NONE; |
| |
| return 0; |
| } |
| |
| /* |
| * Get user display data |
| */ |
| static int tx3912fb_get_var(struct fb_var_screeninfo *var, int con, |
| struct fb_info *info) |
| { |
| if (con == -1) |
| *var = tx3912fb_info; |
| else |
| *var = fb_display[con].var; |
| |
| return 0; |
| } |
| |
| /* |
| * Set user display data |
| */ |
| static int tx3912fb_set_var(struct fb_var_screeninfo *var, int con, |
| struct fb_info *info) |
| { |
| int err, activate = var->activate; |
| int oldxres, oldyres, oldvxres, oldvyres, oldbpp; |
| u_long line_length; |
| struct display *display; |
| |
| if (con == -1) |
| display = &global_disp; |
| else |
| display = &fb_display[con]; |
| |
| /* |
| * FB_VMODE_CONUPDATE and FB_VMODE_SMOOTH_XPAN are equal |
| * as FB_VMODE_SMOOTH_XPAN is only used internally |
| */ |
| if (var->vmode & FB_VMODE_CONUPDATE) { |
| var->xoffset = display->var.xoffset; |
| var->yoffset = display->var.yoffset; |
| var->vmode |= FB_VMODE_YWRAP; |
| } |
| |
| /* |
| * Make sure values are in range |
| */ |
| if (!var->xres) |
| var->xres = 1; |
| if (!var->yres) |
| var->yres = 1; |
| if (var->xres > var->xres_virtual) |
| var->xres_virtual = var->xres; |
| if (var->yres > var->yres_virtual) |
| var->yres_virtual = var->yres; |
| if (var->bits_per_pixel <= 1) |
| var->bits_per_pixel = 1; |
| else if (var->bits_per_pixel <= 2) |
| var->bits_per_pixel = 2; |
| else if (var->bits_per_pixel <= 4) |
| var->bits_per_pixel = 4; |
| else if (var->bits_per_pixel <= 8) |
| var->bits_per_pixel = 8; |
| else |
| return -EINVAL; |
| |
| /* |
| * Memory limit |
| */ |
| line_length = get_line_length(var->xres_virtual, var->bits_per_pixel); |
| if ((line_length * var->yres_virtual) > tx3912fb_size) |
| return -ENOMEM; |
| |
| /* |
| * This is only for color and we only support 8-bit color |
| */ |
| if (var->bits_per_pixel) { |
| /* RGB 332 */ |
| var->red.offset = 5; |
| var->red.length = 3; |
| var->green.offset = 2; |
| var->green.length = 3; |
| var->blue.offset = 0; |
| var->blue.length = 2; |
| var->transp.offset = 0; |
| var->transp.length = 0; |
| } |
| var->red.msb_right = 0; |
| var->green.msb_right = 0; |
| var->blue.msb_right = 0; |
| var->transp.msb_right = 0; |
| |
| /* |
| * Make changes if necessary |
| */ |
| if ((activate & FB_ACTIVATE_MASK) == FB_ACTIVATE_NOW) { |
| |
| oldxres = display->var.xres; |
| oldyres = display->var.yres; |
| oldvxres = display->var.xres_virtual; |
| oldvyres = display->var.yres_virtual; |
| oldbpp = display->var.bits_per_pixel; |
| display->var = *var; |
| |
| if (oldxres != var->xres || oldyres != var->yres || |
| oldvxres != var->xres_virtual || |
| oldvyres != var->yres_virtual || |
| oldbpp != var->bits_per_pixel) { |
| |
| display->screen_base = (u_char *) tx3912fb_vaddr; |
| |
| switch (var->bits_per_pixel) { |
| case 1: |
| display->visual = FB_VISUAL_MONO10; |
| break; |
| case 2: |
| display->visual = FB_VISUAL_PSEUDOCOLOR; |
| case 4: |
| case 8: |
| display->visual = FB_VISUAL_TRUECOLOR; |
| break; |
| } |
| |
| display->type = FB_TYPE_PACKED_PIXELS; |
| display->type_aux = 0; |
| display->ypanstep = 0; |
| display->ywrapstep = 0; |
| display->next_line = |
| display->line_length = |
| get_line_length(var->xres_virtual, |
| var->bits_per_pixel); |
| display->can_soft_blank = 0; |
| display->inverse = FB_IS_INVERSE; |
| |
| switch (var->bits_per_pixel) { |
| #ifdef CONFIG_FBCON_MFB |
| case 1: |
| display->dispsw = &fbcon_mfb; |
| break; |
| #endif |
| #ifdef CONFIG_FBCON_CFB2 |
| case 2: |
| display->dispsw = &fbcon_cfb2; |
| break; |
| #endif |
| #ifdef CONFIG_FBCON_CFB4 |
| case 4: |
| display->dispsw = &fbcon_cfb4; |
| break; |
| #endif |
| #ifdef CONFIG_FBCON_CFB8 |
| case 8: |
| display->dispsw = &fbcon_cfb8; |
| display->dispsw_data = fbcon_cmap.cfb8; |
| break; |
| #endif |
| default: |
| display->dispsw = &fbcon_dummy; |
| break; |
| } |
| |
| if (fb_info.changevar) |
| (*fb_info.changevar)(con); |
| } |
| |
| if (oldbpp != var->bits_per_pixel) { |
| if ((err = fb_alloc_cmap(&display->cmap, 0, 0))) |
| return err; |
| tx3912fb_install_cmap(con, info); |
| } |
| } |
| |
| return 0; |
| } |
| |
| /* |
| * Get the colormap |
| */ |
| static int tx3912fb_get_cmap(struct fb_cmap *cmap, int kspc, int con, |
| struct fb_info *info) |
| { |
| if (con == currcon) |
| return fb_get_cmap(cmap, kspc, tx3912fb_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 tx3912fb_set_cmap(struct fb_cmap *cmap, int kspc, int con, |
| struct fb_info *info) |
| { |
| int err; |
| |
| if (!fb_display[con].cmap.len) |
| if ((err = fb_alloc_cmap(&fb_display[con].cmap, |
| 1<<fb_display[con].var.bits_per_pixel, 0))) |
| return err; |
| |
| if (con == currcon) |
| return fb_set_cmap(cmap, kspc, tx3912fb_setcolreg, info); |
| else |
| fb_copy_cmap(cmap, &fb_display[con].cmap, kspc ? 0 : 1); |
| |
| return 0; |
| } |
| |
| /* |
| * Framebuffer ioctl |
| */ |
| static int tx3912fb_ioctl(struct inode *inode, struct file *file, u_int cmd, |
| u_long arg, int con, struct fb_info *info) |
| { |
| return -EINVAL; |
| } |
| |
| /* |
| * Initialization of the framebuffer |
| */ |
| int __init tx3912fb_init(void) |
| { |
| /* Disable the video logic */ |
| outl(inl(TX3912_VIDEO_CTRL1) & |
| ~(TX3912_VIDEO_CTRL1_ENVID | TX3912_VIDEO_CTRL1_DISPON), |
| TX3912_VIDEO_CTRL1); |
| udelay(200); |
| |
| /* Set start address for DMA transfer */ |
| outl(tx3912fb_paddr, TX3912_VIDEO_CTRL3); |
| |
| /* Set end address for DMA transfer */ |
| outl((tx3912fb_paddr + tx3912fb_size + 1), TX3912_VIDEO_CTRL4); |
| |
| /* Set the pixel depth */ |
| switch (tx3912fb_info.bits_per_pixel) { |
| case 1: |
| /* Monochrome */ |
| outl(inl(TX3912_VIDEO_CTRL1) & ~TX3912_VIDEO_CTRL1_BITSEL_MASK, |
| TX3912_VIDEO_CTRL1); |
| break; |
| case 4: |
| /* 4-bit gray */ |
| outl(inl(TX3912_VIDEO_CTRL1) & ~TX3912_VIDEO_CTRL1_BITSEL_MASK, |
| TX3912_VIDEO_CTRL1); |
| outl(inl(TX3912_VIDEO_CTRL1) | |
| TX3912_VIDEO_CTRL1_BITSEL_4BIT_GRAY, |
| TX3912_VIDEO_CTRL1); |
| break; |
| case 8: |
| /* 8-bit color */ |
| outl(inl(TX3912_VIDEO_CTRL1) & ~TX3912_VIDEO_CTRL1_BITSEL_MASK, |
| TX3912_VIDEO_CTRL1); |
| outl(inl(TX3912_VIDEO_CTRL1) | |
| TX3912_VIDEO_CTRL1_BITSEL_8BIT_COLOR, |
| TX3912_VIDEO_CTRL1); |
| break; |
| case 2: |
| default: |
| /* 2-bit gray */ |
| outl(inl(TX3912_VIDEO_CTRL1) & ~TX3912_VIDEO_CTRL1_BITSEL_MASK, |
| TX3912_VIDEO_CTRL1); |
| outl(inl(TX3912_VIDEO_CTRL1) | |
| TX3912_VIDEO_CTRL1_BITSEL_2BIT_GRAY, |
| TX3912_VIDEO_CTRL1); |
| break; |
| } |
| |
| /* Enable the video clock */ |
| outl(inl(TX3912_CLK_CTRL) | TX3912_CLK_CTRL_ENVIDCLK, |
| TX3912_CLK_CTRL); |
| |
| /* Unfreeze video logic and enable DF toggle */ |
| outl(inl(TX3912_VIDEO_CTRL1) & |
| ~(TX3912_VIDEO_CTRL1_ENFREEZEFRAME | TX3912_VIDEO_CTRL1_DFMODE), |
| TX3912_VIDEO_CTRL1); |
| udelay(200); |
| |
| /* Clear the framebuffer */ |
| memset((void *) tx3912fb_vaddr, 0xff, tx3912fb_size); |
| udelay(200); |
| |
| /* Enable the video logic */ |
| outl(inl(TX3912_VIDEO_CTRL1) | |
| (TX3912_VIDEO_CTRL1_ENVID | TX3912_VIDEO_CTRL1_DISPON), |
| TX3912_VIDEO_CTRL1); |
| |
| strcpy(fb_info.modename, TX3912FB_NAME); |
| fb_info.changevar = NULL; |
| fb_info.node = -1; |
| fb_info.fbops = &tx3912fb_ops; |
| fb_info.disp = &global_disp; |
| fb_info.switch_con = &tx3912fbcon_switch; |
| fb_info.updatevar = &tx3912fbcon_updatevar; |
| fb_info.blank = &tx3912fbcon_blank; |
| fb_info.flags = FBINFO_FLAG_DEFAULT; |
| |
| tx3912fb_set_var(&tx3912fb_info, -1, &fb_info); |
| |
| if (register_framebuffer(&fb_info) < 0) |
| return -1; |
| |
| printk (KERN_INFO "fb%d: TX3912 frame buffer using %uKB.\n", |
| GET_FB_IDX(fb_info.node), (u_int) (tx3912fb_size >> 10)); |
| |
| return 0; |
| } |
| |
| /* |
| * Switch the console to be the framebuffer |
| */ |
| static int tx3912fbcon_switch(int con, struct fb_info *info) |
| { |
| /* Save off the color map if needed */ |
| if (fb_display[currcon].cmap.len) |
| fb_get_cmap(&fb_display[currcon].cmap, 1, |
| tx3912fb_getcolreg, info); |
| |
| /* Make the switch */ |
| currcon = con; |
| |
| /* Install new colormap */ |
| tx3912fb_install_cmap(con, info); |
| |
| return 0; |
| } |
| |
| /* |
| * Update variable structure |
| */ |
| static int tx3912fbcon_updatevar(int con, struct fb_info *info) |
| { |
| /* Nothing */ |
| return 0; |
| } |
| |
| /* |
| * Blank the display |
| */ |
| static void tx3912fbcon_blank(int blank, struct fb_info *info) |
| { |
| /* FIXME */ |
| printk("tx3912fbcon_blank\n"); |
| } |
| |
| /* |
| * Read a single color register |
| */ |
| static int tx3912fb_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; |
| |
| #if FB_IS_GREY |
| { |
| u_int grey; |
| |
| grey = regno * 255 / 15; |
| |
| #if FB_IS_INVERSE |
| grey ^= 255; |
| #endif |
| grey |= grey << 8; |
| *red = grey; |
| *green = grey; |
| *blue = grey; |
| } |
| #else |
| *red = (palette[regno].red<<8) | palette[regno].red; |
| *green = (palette[regno].green<<8) | palette[regno].green; |
| *blue = (palette[regno].blue<<8) | palette[regno].blue; |
| #endif |
| *transp = 0; |
| |
| return 0; |
| } |
| |
| /* |
| * Set a single color register |
| */ |
| static int tx3912fb_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; |
| |
| #ifdef FBCON_HAS_CFB8 |
| if( regno < 16 ) |
| fbcon_cmap.cfb8[regno] = ((red & 0xe000) >> 8) |
| | ((green & 0xe000) >> 11) |
| | ((blue & 0xc000) >> 14); |
| #endif |
| |
| red >>= 8; |
| green >>= 8; |
| blue >>= 8; |
| palette[regno].red = red; |
| palette[regno].green = green; |
| palette[regno].blue = blue; |
| |
| return 0; |
| } |
| |
| /* |
| * Install the color map |
| */ |
| static void tx3912fb_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, tx3912fb_setcolreg, info); |
| else |
| fb_set_cmap(fb_default_cmap(1 << fb_display[con].var.bits_per_pixel), 1, tx3912fb_setcolreg, info); |
| } |
| |
| MODULE_LICENSE("GPL"); |