Subversion Repositories or1k

/*

 *  linux/drivers/char/tga.c

 *

 *  Copyright (C) 1995  Jay Estabrook

 */

/*

 *      tga.c

 *

 * This module exports the console io support for DEC's TGA

 */

#include <linux/config.h> /* CONFIG_VGA_CONSOLE */

#include <linux/sched.h>

#include <linux/timer.h>

#include <linux/interrupt.h>

#include <linux/tty.h>

#include <linux/tty_flip.h>

#include <linux/kernel.h>

#include <linux/string.h>

#include <linux/errno.h>

#include <linux/kd.h>

#include <linux/malloc.h>

#include <linux/major.h>

#include <linux/mm.h>

#include <linux/ioport.h>

#include <linux/bios32.h>

#include <linux/pci.h>

#include <asm/io.h>

#include <asm/system.h>

#include <asm/segment.h>

#include <asm/bitops.h>

#include "kbd_kern.h"

#include "vt_kern.h"

#include "consolemap.h"

#include "selection.h"

#include "console_struct.h"

extern void register_console(void (*proc)(const char *));

extern void console_print(const char *);

extern void set_palette (void); /* vga.c */

/* TGA hardware description (minimal) */

/*

 * Offsets within Memory Space

 */

#define TGA_ROM_OFFSET                  0x0000000

#define TGA_REGS_OFFSET                 0x0100000

#define TGA_8PLANE_FB_OFFSET            0x0200000

#define TGA_24PLANE_FB_OFFSET           0x0804000

#define TGA_24PLUSZ_FB_OFFSET           0x1004000

#define TGA_PLANEMASK_REG               0x0028

#define TGA_MODE_REG                    0x0030

#define TGA_RASTEROP_REG                0x0034

#define TGA_DEEP_REG                    0x0050

#define TGA_PIXELMASK_REG               0x005c

#define TGA_CURSOR_BASE_REG             0x0060

#define TGA_HORIZ_REG                   0x0064

#define TGA_VERT_REG                    0x0068

#define TGA_BASE_ADDR_REG               0x006c

#define TGA_VALID_REG                   0x0070

#define TGA_CURSOR_XY_REG               0x0074

#define TGA_INTR_STAT_REG               0x007c

#define TGA_RAMDAC_SETUP_REG            0x00c0

#define TGA_BLOCK_COLOR0_REG            0x0140

#define TGA_BLOCK_COLOR1_REG            0x0144

#define TGA_CLOCK_REG                   0x01e8

#define TGA_RAMDAC_REG                  0x01f0

#define TGA_CMD_STAT_REG                0x01f8

/*

 * useful defines for managing the BT485 on the 8-plane TGA

 */

#define BT485_READ_BIT                  0x01

#define BT485_WRITE_BIT                 0x00

#define BT485_ADDR_PAL_WRITE            0x00

#define BT485_DATA_PAL                  0x02

#define BT485_PIXEL_MASK                0x04

#define BT485_ADDR_PAL_READ             0x06

#define BT485_ADDR_CUR_WRITE            0x08

#define BT485_DATA_CUR                  0x0a

#define BT485_CMD_0                     0x0c

#define BT485_ADDR_CUR_READ             0x0e

#define BT485_CMD_1                     0x10

#define BT485_CMD_2                     0x12

#define BT485_STATUS                    0x14

#define BT485_CMD_3                     0x14

#define BT485_CUR_RAM                   0x16

#define BT485_CUR_LOW_X                 0x18

#define BT485_CUR_HIGH_X                0x1a

#define BT485_CUR_LOW_Y                 0x1c

#define BT485_CUR_HIGH_Y                0x1e

/*

 * useful defines for managing the BT463 on the 24-plane TGAs

 */

#define BT463_ADDR_LO           0x0

#define BT463_ADDR_HI           0x1

#define BT463_REG_ACC           0x2

#define BT463_PALETTE           0x3

#define BT463_CUR_CLR_0         0x0100

#define BT463_CUR_CLR_1         0x0101

#define BT463_CMD_REG_0         0x0201

#define BT463_CMD_REG_1         0x0202

#define BT463_CMD_REG_2         0x0203

#define BT463_READ_MASK_0       0x0205

#define BT463_READ_MASK_1       0x0206

#define BT463_READ_MASK_2       0x0207

#define BT463_READ_MASK_3       0x0208

#define BT463_BLINK_MASK_0      0x0209

#define BT463_BLINK_MASK_1      0x020a

#define BT463_BLINK_MASK_2      0x020b

#define BT463_BLINK_MASK_3      0x020c

#define BT463_WINDOW_TYPE_BASE  0x0300

/*

 * built-in font management constants

 *

 * NOTE: the built-in font is 8x16, and the video resolution

 * is 640x480 @ 60Hz.

 * This means we could put 30 rows of text on the screen (480/16).

 * However, we wish to make then TGA look just like a VGA, as the

 * default, so, we pad the character to 8x18, and leave some scan

 * lines at the bottom unused.

 */

#define TGA_F_WIDTH 8

#define TGA_F_HEIGHT 16

#define TGA_F_HEIGHT_PADDED 18

int tga_type;

unsigned int tga_mem_base;

unsigned long tga_fb_base;

unsigned long tga_regs_base;

unsigned int tga_bpp, tga_fb_width, tga_fb_height, tga_fb_stride;

static unsigned int fb_offset_presets[4] = {

        TGA_8PLANE_FB_OFFSET,

        TGA_24PLANE_FB_OFFSET,

        0xffffffff,

        TGA_24PLUSZ_FB_OFFSET

};

static unsigned int deep_presets[4] = {

  0x00014000,

  0x0001440d,

  0xffffffff,

  0x0001441d

};

static unsigned int rasterop_presets[4] = {

  0x00000003,

  0x00000303,

  0xffffffff,

  0x00000303

};

static unsigned int mode_presets[4] = {

  0x00002000,

  0x00002300,

  0xffffffff,

  0x00002300

};

static unsigned int base_addr_presets[4] = {

  0x00000000,

  0x00000001,

  0xffffffff,

  0x00000001

};

#define TGA_WRITE_REG(v,r) \

        { writel((v), tga_regs_base+(r)); mb(); }

#define TGA_READ_REG(r) readl(tga_regs_base+(r))

#define BT485_WRITE(v,r) \

          TGA_WRITE_REG((r),TGA_RAMDAC_SETUP_REG);              \

          TGA_WRITE_REG(((v)&0xff)|((r)<<8),TGA_RAMDAC_REG);

#define BT463_LOAD_ADDR(a) \

        TGA_WRITE_REG(BT463_ADDR_LO<<2, TGA_RAMDAC_SETUP_REG); \

        TGA_WRITE_REG((BT463_ADDR_LO<<10)|((a)&0xff), TGA_RAMDAC_REG); \

        TGA_WRITE_REG(BT463_ADDR_HI<<2, TGA_RAMDAC_SETUP_REG); \

        TGA_WRITE_REG((BT463_ADDR_HI<<10)|(((a)>>8)&0xff), TGA_RAMDAC_REG);

#define BT463_WRITE(m,a,v) \

        BT463_LOAD_ADDR((a)); \

        TGA_WRITE_REG(((m)<<2),TGA_RAMDAC_SETUP_REG); \

        TGA_WRITE_REG(((m)<<10)|((v)&0xff),TGA_RAMDAC_REG);

extern char tga_builtin_font[];

void tga_init_video(void);

void tga_clear_screen(void);

void

tga_set_palette (void)

{

  int i, j;

  if (console_blanked || vt_cons[fg_console]->vc_mode == KD_GRAPHICS)

    return;

  if (tga_type == 0) { /* 8-plane */

    BT485_WRITE(0x00, BT485_ADDR_PAL_WRITE);

    TGA_WRITE_REG(BT485_DATA_PAL, TGA_RAMDAC_SETUP_REG);

    for (i = 0; i < 16; i++) {

     j = color_table[i];

     TGA_WRITE_REG(default_red[j]|(BT485_DATA_PAL<<8),TGA_RAMDAC_REG);

     TGA_WRITE_REG(default_grn[j]|(BT485_DATA_PAL<<8),TGA_RAMDAC_REG);

     TGA_WRITE_REG(default_blu[j]|(BT485_DATA_PAL<<8),TGA_RAMDAC_REG);

   }

  } else {

    BT463_LOAD_ADDR(0x0000);

    TGA_WRITE_REG((BT463_PALETTE<<2), TGA_RAMDAC_REG);

    for (i = 0; i < 16; i++) {

      j = color_table[i];

      TGA_WRITE_REG(default_red[j]|(BT463_PALETTE<<10), TGA_RAMDAC_REG);

      TGA_WRITE_REG(default_grn[j]|(BT463_PALETTE<<10), TGA_RAMDAC_REG);

      TGA_WRITE_REG(default_blu[j]|(BT463_PALETTE<<10), TGA_RAMDAC_REG);

    }

  }

}

void

tga_set_origin(unsigned short offset)

{

  /*

   * should not be called, but if so, do nothing...

   */

}

/*

 * Hide the cursor from view, during blanking, usually...

 */

void

tga_hide_cursor(void)

{

        unsigned long flags;

        save_flags(flags); cli();

        if (tga_type == 0) {

          BT485_WRITE(0x20, BT485_CMD_2);

        } else {

          TGA_WRITE_REG(0x03, TGA_VALID_REG); /* SCANNING and BLANK */

        }

        restore_flags(flags);

}

void

tga_set_cursor(int currcons)

{

  unsigned int idx, xt, yt, row, col;

  unsigned long flags;

  if (currcons != fg_console || console_blanked || vcmode == KD_GRAPHICS)

    return;

#if 0

  if (__real_origin != __origin)

    tga_set_origin(__real_origin);

#endif

  save_flags(flags); cli();

  if (deccm) {

    idx = (pos - video_mem_base) >> 1;

    col = idx % 80;

    row = (idx - col) / 80;

    if (tga_type == 0) { /* 8-plane */

      xt = col * TGA_F_WIDTH + 64;

      yt = row * TGA_F_HEIGHT_PADDED + 64;

      /* make sure it's enabled */

      BT485_WRITE(0x22, BT485_CMD_2); /* WIN cursor type */

      BT485_WRITE(xt, BT485_CUR_LOW_X);

      BT485_WRITE((xt >> 8), BT485_CUR_HIGH_X);

      BT485_WRITE(yt, BT485_CUR_LOW_Y);

      BT485_WRITE((yt >> 8), BT485_CUR_HIGH_Y);

    } else {

      xt = col * TGA_F_WIDTH + 144;

      yt = row * TGA_F_HEIGHT_PADDED + 35;

      TGA_WRITE_REG(0x05, TGA_VALID_REG); /* SCANNING and CURSOR */

      TGA_WRITE_REG(xt | (yt << 12), TGA_CURSOR_XY_REG);

    }

  } else

    tga_hide_cursor();

  restore_flags(flags);

}

unsigned long

tga_init(unsigned long kmem_start, const char **display_desc)

{

        can_do_color = 1;

        /*

        * fake the screen memory with some CPU memory

        */

        video_mem_base = kmem_start;

        kmem_start += video_screen_size;

        video_mem_term = kmem_start;

        video_type = VIDEO_TYPE_TGAC;

        *display_desc = "TGA";

        return kmem_start;

}

/*

 * NOTE: get_scrmem() and set_scrmem() are here only because

 * the VGA version of set_scrmem() has some direct VGA references.

 */

void

tga_get_scrmem(int currcons)

{

        memcpyw((unsigned short *)vc_scrbuf[currcons],

                (unsigned short *)origin, video_screen_size);

        origin = video_mem_start = (unsigned long)vc_scrbuf[currcons];

        scr_end = video_mem_end = video_mem_start + video_screen_size;

        pos = origin + y*video_size_row + (x<<1);

}

void

tga_set_scrmem(int currcons, long offset)

{

        if (video_mem_term - video_mem_base < offset + video_screen_size)

          offset = 0;    /* strange ... */

        memcpyw((unsigned short *)(video_mem_base + offset),

                (unsigned short *) origin, video_screen_size);

        video_mem_start = video_mem_base;

        video_mem_end = video_mem_term;

        origin = video_mem_base + offset;

        scr_end = origin + video_screen_size;

        pos = origin + y*video_size_row + (x<<1);

}

/*

 * PIO_FONT support.

 *

 * for now, we will use/allow *only* our built-in font...

 */

int

tga_set_get_font(char * arg, int set, int ch512)

{

        return -EINVAL;

}

/*

 * Adjust the screen to fit a font of a certain height

 *

 * Returns < 0 for error, 0 if nothing changed, and the number

 * of lines on the adjusted console if changed.

 *

 * for now, we only support the built-in font...

 */

int

tga_adjust_height(unsigned long fontheight)

{

        return -EINVAL;

}

/* NOTE:

 * this is here, and not in console.c, because the VGA version

 * tests the controller type to see if color can be done. We *KNOW*

 * that we can do color on the TGA... :-)

 *

 * FIXME? maybe the init codes for VGA and TGA could set

 * a flag for (in)ability to do colormap set/get???

 */

int

tga_set_get_cmap(unsigned char * arg, int set) {

        int i;

        i = verify_area(set ? VERIFY_READ : VERIFY_WRITE, (void *)arg, 16*3);

        if (i)

                return i;

        for (i=0; i<16; i++) {

                if (set) {

                        default_red[i] = get_user(arg++) ;

                        default_grn[i] = get_user(arg++) ;

                        default_blu[i] = get_user(arg++) ;

                } else {

                        put_user (default_red[i], arg++) ;

                        put_user (default_grn[i], arg++) ;

                        put_user (default_blu[i], arg++) ;

                }

        }

        if (set) {

                for (i=0; i<MAX_NR_CONSOLES; i++)

                    if (vc_cons_allocated(i)) {

                        int j, k ;

                        for (j=k=0; j<16; j++) {

                            vc_cons[i].d->vc_palette[k++] = default_red[j];

                            vc_cons[i].d->vc_palette[k++] = default_grn[j];

                            vc_cons[i].d->vc_palette[k++] = default_blu[j];

                        }

                    }

                set_palette() ;

        }

        return 0;

}

/*

 * dummy routines for the VESA blanking code, which is VGA only,

 * so we don't have to carry that stuff around for the TGA...

 */

void tga_vesa_powerdown(void)

{

}

void tga_vesa_blank(void)

{

}

void tga_vesa_unblank(void)

{

}

void tga_set_vesa_blanking(const unsigned long arg)

{

}

/*

 * video init code, called from within the PCI bus probing code;

 * when TGA console is configured, at the end of the probing code,

 * we call here to look for a TGA device, and proceed...

 *

 * note that this code MUST be called BEFORE console_init/con_init,

 * so that either VGA or TGA are set up but not both. we had to move

 * console_init to after pci_init in start_kernel to assure this.

 */

void

tga_console_find(void)

{

        unsigned char pci_bus, pci_devfn;

        int status;

        /*

         * first, find the TGA among the PCI devices...

         */

        status = pcibios_find_device (PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_TGA,

                                      0, &pci_bus, &pci_devfn);

        if (status == PCIBIOS_DEVICE_NOT_FOUND) {

                /* PANIC!!! */

                printk("tga_console_init: TGA not found!!! :-(\n");

                return;

        }

        /*

         * read BASE_REG_0 for memory address

         */

        pcibios_read_config_dword(pci_bus, pci_devfn,

                                  PCI_BASE_ADDRESS_0, &tga_mem_base);

        tga_mem_base &= ~15;

#ifdef DEBUG

        printk("tga_console_init: mem_base 0x%x\n", tga_mem_base);

#endif /* DEBUG */

        tga_type = (readl((unsigned long)tga_mem_base) >> 12) & 0x0f;

        if (tga_type != 0 && tga_type != 1 && tga_type != 3) {

          printk("TGA type (0x%x) unrecognized!\n", tga_type);

          return;

        }

        tga_init_video();

        tga_clear_screen();

}

unsigned char PLLbits[7] = { 0x80, 0x04, 0x00, 0x24, 0x44, 0x80, 0xb8 };

const unsigned long bt485_cursor_source[64] = {

  0x00000000000000ff,0x00000000000000ff,0x00000000000000ff,0x00000000000000ff,

  0x00000000000000ff,0x00000000000000ff,0x00000000000000ff,0x00000000000000ff,

  0x00000000000000ff,0x00000000000000ff,0x00000000000000ff,0x00000000000000ff,

  0x00000000000000ff,0x00000000000000ff,0x00000000000000ff,0x00000000000000ff,

  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0

};

const unsigned int bt463_cursor_source[256] = {

  0xffff0000, 0x00000000, 0x00000000, 0x00000000,

  0xffff0000, 0x00000000, 0x00000000, 0x00000000,

  0xffff0000, 0x00000000, 0x00000000, 0x00000000,

  0xffff0000, 0x00000000, 0x00000000, 0x00000000,

  0xffff0000, 0x00000000, 0x00000000, 0x00000000,

  0xffff0000, 0x00000000, 0x00000000, 0x00000000,

  0xffff0000, 0x00000000, 0x00000000, 0x00000000,

  0xffff0000, 0x00000000, 0x00000000, 0x00000000,

  0xffff0000, 0x00000000, 0x00000000, 0x00000000,

  0xffff0000, 0x00000000, 0x00000000, 0x00000000,

  0xffff0000, 0x00000000, 0x00000000, 0x00000000,

  0xffff0000, 0x00000000, 0x00000000, 0x00000000,

  0xffff0000, 0x00000000, 0x00000000, 0x00000000,

  0xffff0000, 0x00000000, 0x00000000, 0x00000000,

  0xffff0000, 0x00000000, 0x00000000, 0x00000000,

  0xffff0000, 0x00000000, 0x00000000, 0x00000000,

  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0

};

void

tga_init_video()

{

        int i, j, temp;

        unsigned char *cbp;

        tga_regs_base = ((unsigned long)tga_mem_base + TGA_REGS_OFFSET);

        tga_fb_base =

          ((unsigned long)tga_mem_base + fb_offset_presets[tga_type]);

        /* first, disable video timing */

        TGA_WRITE_REG(0x03, TGA_VALID_REG); /* SCANNING and BLANK */

        /* write the DEEP register */

        while (TGA_READ_REG(TGA_CMD_STAT_REG) & 1) /* wait for not busy */

          continue;

        mb();

        TGA_WRITE_REG(deep_presets[tga_type], TGA_DEEP_REG);

        while (TGA_READ_REG(TGA_CMD_STAT_REG) & 1) /* wait for not busy */

          continue;

        mb();

        /* write some more registers */

        TGA_WRITE_REG(rasterop_presets[tga_type], TGA_RASTEROP_REG);

        TGA_WRITE_REG(mode_presets[tga_type], TGA_MODE_REG);

        TGA_WRITE_REG(base_addr_presets[tga_type], TGA_BASE_ADDR_REG);

        /* write the PLL for 640x480 @ 60Hz */

        for (i = 0; i <= 6; i++) {

          for (j = 0; j <= 7; j++) {

            temp = (PLLbits[i] >> (7-j)) & 1;

            if (i == 6 && j == 7)

              temp |= 2;

            TGA_WRITE_REG(temp, TGA_CLOCK_REG);

          }

        }

        /* write some more registers */

        TGA_WRITE_REG(0xffffffff, TGA_PLANEMASK_REG);

        TGA_WRITE_REG(0xffffffff, TGA_PIXELMASK_REG);

        TGA_WRITE_REG(0x12345678, TGA_BLOCK_COLOR0_REG);

        TGA_WRITE_REG(0x12345678, TGA_BLOCK_COLOR1_REG);

        /* init video timing regs for 640x480 @ 60 Hz */

        TGA_WRITE_REG(0x018608a0, TGA_HORIZ_REG);

        TGA_WRITE_REG(0x084251e0, TGA_VERT_REG);

        if (tga_type == 0) { /* 8-plane */

          tga_bpp = 1;

          /* init BT485 RAMDAC registers */

          BT485_WRITE(0xa2, BT485_CMD_0);

          BT485_WRITE(0x01, BT485_ADDR_PAL_WRITE);

          BT485_WRITE(0x14, BT485_CMD_3); /* cursor 64x64 */

          BT485_WRITE(0x40, BT485_CMD_1);

          BT485_WRITE(0x22, BT485_CMD_2); /* WIN cursor type */

          BT485_WRITE(0xff, BT485_PIXEL_MASK);

          /* fill palette registers */

          BT485_WRITE(0x00, BT485_ADDR_PAL_WRITE);

          TGA_WRITE_REG(BT485_DATA_PAL, TGA_RAMDAC_SETUP_REG);

          for (i = 0; i < 16; i++) {

            j = color_table[i];

            TGA_WRITE_REG(default_red[j]|(BT485_DATA_PAL<<8),

                          TGA_RAMDAC_REG);

            TGA_WRITE_REG(default_grn[j]|(BT485_DATA_PAL<<8),

                          TGA_RAMDAC_REG);

            TGA_WRITE_REG(default_blu[j]|(BT485_DATA_PAL<<8),

                          TGA_RAMDAC_REG);

          }

          for (i = 0; i < 240*3; i += 4) {

            TGA_WRITE_REG(0x55|(BT485_DATA_PAL<<8), TGA_RAMDAC_REG);

            TGA_WRITE_REG(0x00|(BT485_DATA_PAL<<8), TGA_RAMDAC_REG);

            TGA_WRITE_REG(0x00|(BT485_DATA_PAL<<8), TGA_RAMDAC_REG);

            TGA_WRITE_REG(0x00|(BT485_DATA_PAL<<8), TGA_RAMDAC_REG);

          }

          /* initialize RAMDAC cursor colors */

          BT485_WRITE(0, BT485_ADDR_CUR_WRITE);

          BT485_WRITE(0xaa, BT485_DATA_CUR); /* overscan WHITE */

          BT485_WRITE(0xaa, BT485_DATA_CUR); /* overscan WHITE */

          BT485_WRITE(0xaa, BT485_DATA_CUR); /* overscan WHITE */

          BT485_WRITE(0x00, BT485_DATA_CUR); /* color 1 BLACK */

          BT485_WRITE(0x00, BT485_DATA_CUR); /* color 1 BLACK */

          BT485_WRITE(0x00, BT485_DATA_CUR); /* color 1 BLACK */