Subversion Repositories or1k

/* suncons.c: Sun SparcStation console support.

 *

 * Copyright (C) 1995 Peter Zaitcev (zaitcev@lab.ipmce.su)

 * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)

 * Copyright (C) 1995 Miguel de Icaza (miguel@nuclecu.unam.mx)

 *

 * Added font loading Nov/21, Miguel de Icaza (miguel@nuclecu.unam.mx)

 * Added render_screen and faster scrolling Nov/27, miguel

 * Added console palette code for cg6 Dec/13/95, miguel

 * Added generic frame buffer support Dec/14/95, miguel

 * Added cgsix and bwtwo drivers Jan/96, miguel

 * Added 4m, and cg3 driver Feb/96, miguel

 * Fixed the cursor on color displays Feb/96, miguel.

 *

 * Cleaned up the detection code, generic 8bit depth display

 * code, Mar/96 miguel

 *

 * This file contains the frame buffer device drivers.

 * Each driver is kept together in case we would like to

 * split this file.

 *

 * Much of this driver is derived from the DEC TGA driver by

 * Jay Estabrook who has done a nice job with the console

 * driver abstraction btw.

 *

 * We try to make everything a power of two if possible to

 * speed up the bit blit.  Doing multiplies, divides, and

 * remainder routines end up calling software library routines

 * since not all Sparcs have the hardware to do it.

 *

 * TODO:

 * do not use minor to index into instances of the frame buffer,

 * since the numbers assigned to us are not consecutive.

 *

 * do not blank the screen when frame buffer is mapped.

 *

 * Change the detection loop to use more than one video card.

 */

/* Define this one if you are debugging something in X, it will not disable the console output */

/* #define DEBUGGING_X */

/* See also: sparc/keyboard.c: CODING_NEW_DRIVER */

#define GRAPHDEV_MAJOR 29

#define FRAME_BUFFERS 1

#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/types.h>

#include <asm/system.h>

#include <asm/segment.h>

#include <asm/page.h>

#include <asm/pgtable.h>

#include <asm/bitops.h>

#include <asm/oplib.h>

#include <asm/sbus.h>

#include <asm/fbio.h>

#include <asm/io.h>

#include <asm/pgtsun4c.h>       /* for the sun4c_nocache */

#include "../../char/kbd_kern.h"

#include "../../char/vt_kern.h"

#include "../../char/consolemap.h"

#include "../../char/selection.h"

#include "../../char/console_struct.h"

#define cmapsz 8192

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

extern void console_print(const char *);

extern unsigned char vga_font[];

extern int graphics_on;

extern int serial_console;

/* Based upon what the PROM tells us, we can figure out where

 * the console is currently located.  The situation can be either

 * of the following two scenarios:

 *

 * 1) Console i/o is done over the serial line, ttya or ttyb

 * 2) Console output on frame buffer (video card) and input

 *    coming from the keyboard/mouse which each use a zilog8530

 *    serial channel a piece.

 */

/* The following variables describe a Sparc console. */

/* From the PROM */

static char con_name[40];

/* Screen dimensions and color depth. */

static int con_depth, con_width, con_height, con_type;

static int con_linebytes;

/* Base address of first line. */

static unsigned char *con_fb_base;

/* Screen parameters: we compute those at startup to make the code faster */

static int chars_per_line;      /* number of bytes per line */

static int ints_per_line;       /* number of ints per  line */

static int skip_bytes;          /* number of bytes we skip for the y margin */

static int x_margin, y_margin;  /* the x and y margins */

static int bytes_per_row;       /* bytes used by one screen line (of 16 scan lines)  */

/* Functions used by the SPARC dependent console code

 * to perform the restore_palette function.

 */

static void (*restore_palette)(void);

void set_palette (void);

 /* Our screen looks like at 1152 X 900:

 *

 *  0,0

 *      ------------------------------------------------------------------

 *      |                          ^^^^^^^^^^^                           |

 *      |                          18 y-pixels                           |

 *      |                          ^^^^^^^^^^^                           |

 *   13 | <-64 pixels->|  <-- 128 8x16 characters -->    | <-64 pixels-> |

 *    ....

 *                         54 chars from top to bottom

 *    ....

 *  888 | <-64 pixels->|  <-- 128 8x16 characters -->    | <-64 pixels-> |

 *      |                          ^^^^^^^^^^^                           |

 *      |                          18 y-pixels                           |

 *      |                          ^^^^^^^^^^^                           |

 *      ------------------------------------------------------------------

 */

/* First for MONO displays. */

#define SCREEN_WIDTH     1152     /* Screen width in pixels  */

#define SCREEN_HEIGHT    900      /* Screen height in pixels */

#define CHARS_PER_LINE   144      /* Make this empirical for speed */

#define NICE_Y_MARGIN    18       /* We skip 18 y-pixels at top/bottom */

#define NICE_X_MARGIN    8        /* We skip 64 x-pixels at left/right */

#define FBUF_TOP_SKIP    2592     /* Empirical, (CHARS_PER_LINE * NICE_Y_MARGIN) */

#define CHAR_HEIGHT      16

#define ONE_ROW          2304     /* CHARS_PER_LINE * CHAR_HEIGHT */

/* Now we have this, to compute the base frame buffer position

 * for a new character to be rendered. 1 and 8 bit depth.

 */

#define FBUF_OFFSET(cindex) \

        (((FBUF_TOP_SKIP) + (((cindex)>>7) * ONE_ROW)) + \

         ((NICE_X_MARGIN) + (((cindex)&127))))

#define COLOR_FBUF_OFFSET(cindex) \

        (((skip_bytes) + (((cindex)>>7) * bytes_per_row)) + \

         ((x_margin) + (((cindex)&127) << 3)))

void

__set_origin(unsigned short offset)

{

        /*

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

         */

}

/* For the cursor, we just invert the 8x16 block at the cursor

 * location.  Easy enough...

 *

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

 */

static int cursor_pos = -1;

void

hide_cursor(void)

{

        unsigned long flags;

        int j;

        save_flags(flags); cli();

        if(cursor_pos == -1) {

                restore_flags (flags);

                return;

        }

        /* We just zero out the area for now.  Certain graphics

         * cards like the cg6 have a hardware cursor that we could

         * use, but this is an optimization for some time later.

         */

        switch (con_depth){

        case 1: {

                unsigned char *dst;

                dst = (unsigned char *)((unsigned long)con_fb_base +

                                        FBUF_OFFSET(cursor_pos));

                for(j = 0; j < CHAR_HEIGHT; j++, dst += CHARS_PER_LINE)

                        *dst = ~(0);

                break;

        }

        case 8: {

                unsigned long *dst;

                const    int ipl = ints_per_line;

                dst = (unsigned long *)((unsigned long)con_fb_base + COLOR_FBUF_OFFSET(cursor_pos));

                for(j = 0; j < CHAR_HEIGHT; j++, dst += ipl) {

                        *dst = ~(0UL);

                        *(dst + 1) = ~(0UL);

                }

                break;

        }

        default:

                break;

        }

        restore_flags(flags);

}

/* The idea is the following:

 * we only use the colors in the range 0..15, and we only

 * setup the palette on that range, so we better keep the

 * pixel inversion using those colors, that's why we have

 * those constants below.

 */

inline static void

cursor_reverse (long *dst, int height, const int ints_on_line)

{

    int j;

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

        *dst     = ~(*dst)     & 0x0f0f0f0f;

        *(dst+1) = ~(*(dst+1)) & 0x0f0f0f0f;

        dst += ints_on_line;

    }

}

void

set_cursor(int currcons)

{

        int j, idx, oldpos;

        unsigned long flags;

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

                return;

        if (__real_origin != __origin)

                __set_origin(__real_origin);

        save_flags(flags); cli();

        idx = (pos - video_mem_base) >> 1;

        oldpos = cursor_pos;

        cursor_pos = idx;

        if (!deccm) {

                hide_cursor ();

                restore_flags (flags);

                return;

        }

        switch (con_depth){

        case 1: {

                unsigned char *dst, *opos;

                dst = (unsigned char *)((unsigned long)con_fb_base + FBUF_OFFSET(idx));

                opos = (unsigned char *)((unsigned long)con_fb_base + FBUF_OFFSET(oldpos));

                if(oldpos != -1) {

                        /* Restore what was at the old position */

                        for(j=0; j < CHAR_HEIGHT; j++, opos += CHARS_PER_LINE) {

                                *opos = ~*opos;

                        }

                }

                for(j=0; j < 16; j++, dst+=CHARS_PER_LINE) {

                        *dst = ~*dst;

                }

                break;

        }

        case 8: {

                unsigned long *dst, *opos;

                dst = (unsigned long *)((unsigned long)con_fb_base + COLOR_FBUF_OFFSET(idx));

                opos = (unsigned long *)((unsigned long)con_fb_base + COLOR_FBUF_OFFSET(oldpos));

                if(oldpos != -1)

                        cursor_reverse(opos, CHAR_HEIGHT, ints_per_line);

                cursor_reverse (dst, CHAR_HEIGHT, ints_per_line);

                break;

        }

        default:

        }

        restore_flags(flags);

}

/*

 * Render the current screen

 * Only used at startup to avoid the caching that is being done in selection.h

 */

static void

render_screen(void)

{

    int count;

    unsigned short *contents;

    count = video_num_columns * video_num_lines;

    contents = (unsigned short *) video_mem_base;

    for (;count--; contents++)

        sun_blitc (*contents, (unsigned long) contents);

}

unsigned long

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

{

        can_do_color = (con_type != FBTYPE_SUN2BW);

        video_type = VIDEO_TYPE_SUN;

        *display_desc = "SUN";

        if (!serial_console) {

                /* If we fall back to PROM than our output have to remain readable. */

                prom_putchar('\033');  prom_putchar('[');  prom_putchar('H');

                /*

                 * fake the screen memory with some CPU memory

                 */

                video_mem_base = kmem_start;

                kmem_start += video_screen_size;

                video_mem_term = kmem_start;

                render_screen();

        }

        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

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

set_scrmem(int currcons, long offset)

{

        if (video_mem_term - video_mem_base < offset + video_screen_size)

                offset = 0;

        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.

 */

int

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

{

        int error, i, line;

        if (!arg)

                return -EINVAL;

        error = verify_area (set ? VERIFY_READ : VERIFY_WRITE, (void *) arg,

                             ch512 ? 2* cmapsz : cmapsz);

        if (error)

                return error;

        /* download the current font */

        if (!set){

                memset (arg, 0, cmapsz);

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

                    for (line = 0; line < CHAR_HEIGHT; line++)

                        put_user (vga_font [i], arg+(i*32+line));

                return 0;

        }

        /* set the font */

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

                for (line = 0; line < CHAR_HEIGHT; line++){

                        vga_font [i*CHAR_HEIGHT + line] = (get_user (arg + (i * 32 + line)));

                        if (con_depth == 1)

                                vga_font [i*CHAR_HEIGHT + line] = vga_font [i*CHAR_HEIGHT + line];

                }

        return 0;

}

/*

 * 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

con_adjust_height(unsigned long fontheight)

{

        return -EINVAL;

}

int

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;

}

void

sun_clear_screen(void)

{

        memset (con_fb_base, (con_depth == 1 ? ~(0) : (0)),

                (con_depth * con_height * con_width) / 8);

        /* also clear out the "shadow" screen memory */

        memset((char *)video_mem_base, 0, (video_mem_term - video_mem_base));

}

/*

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

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

 */

void vesa_blank(void)

{

}

void vesa_unblank(void)

{

}

void set_vesa_blanking(const unsigned long arg)

{

}

void vesa_powerdown(void)

{

}

#undef color

/* cg6 cursor status, kernel tracked copy */

struct cg6_cursor {

        short   enable;         /* cursor is enabled */

        struct  fbcurpos cpos;  /* position */

        struct  fbcurpos chot;  /* hot-spot */

        struct  fbcurpos size;  /* size of mask & image fields */

        int     bits[2][32];    /* space for mask & image bits */

        char    color [6];      /* cursor colors */

};

struct cg6_info {

        struct bt_regs *bt;     /* color control */

        void *fbc;

        struct cg6_fhc *fhc;

        struct cg6_tec *tec;

        struct cg6_thc *thc;

        struct cg6_cursor cursor; /* cursor control */

        void *dhc;

};

struct bwtwo_info {

        struct bwtwo_regs *regs;

};

struct cg3_info {

        struct bt_regs *bt;     /* brooktree (color) registers */

};

/* Array holding the information for the frame buffers */

typedef struct {

        union {

                struct bwtwo_info bwtwo;

                struct cg3_info   cg3;

                struct cg6_info   cg6;

        } info;                 /* per frame information */

        int    space;           /* I/O space this card resides in */

        int    blanked;         /* true if video blanked */

        int    open;            /* is this fb open? */

        int    mmaped;          /* has this fb been mmapped? */

        int    vtconsole;       /* virtual console where it is opened */

        long   base;            /* frame buffer base    */

        struct fbtype type;     /* frame buffer type    */

        int    (*mmap)(struct inode *, struct file *, struct vm_area_struct *, long fb_base, void *);

        void   (*loadcmap)(void *this, int index, int count);

        void   (*blank)(void *this);

        void   (*unblank)(void *this);

        int    (*ioctl)(struct inode *, struct file *, unsigned int, unsigned long, void *);

} fbinfo_t;

static fbinfo_t fbinfo [FRAME_BUFFERS];

/* We need to keep a copy of the color map to answer ioctl requests */

static union {

        unsigned char   map[256][3];    /* reasonable way to access */

        unsigned int    raw[256*3/4];   /* hardware wants it like this */

} color_map;

#define FB_MMAP_VM_FLAGS (VM_SHM| VM_LOCKED)

static int

fb_open (struct inode * inode, struct file * file)

{

        int minor = MINOR (inode->i_rdev);

        if (minor >= FRAME_BUFFERS)

                return -EBADF;

        if (fbinfo [minor].open)

                return -EBUSY;

        fbinfo [minor].open = 1;

        fbinfo [minor].mmaped = 0;

        return 0;

}

static int

fb_ioctl (struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)

{

        int minor = MINOR (inode->i_rdev);

        fbinfo_t *fb;

        struct fbcmap *cmap;

        int i;

        if (minor >= FRAME_BUFFERS)

                return -EBADF;

        fb = &fbinfo [minor];

        switch (cmd){

        case FBIOGTYPE:         /* return frame buffer type */

                i = verify_area (VERIFY_WRITE, (void *) arg, sizeof (struct fbtype));

                if (i) return i;

                *(struct fbtype *)arg = (fb->type);

                break;

        case FBIOGATTR:{

                struct fbgattr *fba = (struct fbgattr *) arg;

                i = verify_area (VERIFY_WRITE, (void *) arg, sizeof (struct fbgattr));

                if (i) return i;

                fba->real_type = fb->type.fb_type;

                fba->owner = 0;

                fba->fbtype = fb->type;

                fba->sattr.flags = 0;

                fba->sattr.emu_type = fb->type.fb_type;

                fba->sattr.dev_specific [0] = -1;

                fba->emu_types [0] = fb->type.fb_type;

                fba->emu_types [1] = -1;

                break;

        }

        case FBIOSVIDEO:

                i = verify_area(VERIFY_READ, (void *)arg, sizeof(int));

                if (i) return i;

                if (*(int *)arg){

                        if (!fb->blanked || !fb->unblank)

                                break;

                        (*fb->unblank)(fb);

                        fb->blanked = 0;

                } else {

                        if (fb->blanked || !fb->blank)

                                break;

                        (*fb->blank)(fb);

                        fb->blanked = 1;

                }

                break;

        case FBIOGVIDEO:

                i = verify_area (VERIFY_WRITE, (void *) arg, sizeof (int));

                if (i) return i;

                *(int *) arg = fb->blanked;

                break;

        case FBIOPUTCMAP: {     /* load color map entries */

                char *rp, *gp, *bp;

                int end, count;;

                if (!fb->loadcmap)

                        return -EINVAL;

                i = verify_area (VERIFY_READ, (void *) arg, sizeof (struct fbcmap));

                if (i) return i;

                cmap = (struct fbcmap *) arg;

                count = cmap->count;

                if ((cmap->index < 0) || (cmap->index > 255))

                        return -EINVAL;

                if (cmap->index + count > 256)

                        count = 256 - cmap->index;

                i = verify_area (VERIFY_READ, rp = cmap->red, cmap->count);

                if (i) return i;

                i = verify_area (VERIFY_READ, gp = cmap->green, cmap->count);

                if (i) return i;

                i = verify_area (VERIFY_READ, bp = cmap->blue, cmap->count);

                if (i) return i;

                end = cmap->index + count;

                for (i = cmap->index; i < end; i++){

                        color_map.map [i][0] = *rp++;

                        color_map.map [i][1] = *gp++;

                        color_map.map [i][2] = *bp++;

                }

                (*fb->loadcmap)(fb, cmap->index, count);

                break;

        }

        default:

                if (fb->ioctl){

                        i = fb->ioctl (inode, file, cmd, arg, fb);

                        if (i == -EINVAL)

                                printk ("[[FBIO: %8.8x]]\n", cmd);

                        return i;

                }

                printk ("[[FBIO: %8.8x]]\n", cmd);

                return -EINVAL;

        }

        return 0;

}

static void

fb_close (struct inode * inode, struct file *filp)

{

        int minor = MINOR(inode->i_rdev);

        struct fbcursor cursor;

        if (minor >= FRAME_BUFFERS)

                return;

        if (fbinfo [minor].open)