Subversion Repositories or1k

/*

 *      linux/drivers/video/maxinefb.c

 *

 *      DECstation 5000/xx onboard framebuffer support ... derived from:

 *      "HP300 Topcat framebuffer support (derived from macfb of all things)

 *      Phil Blundell <philb@gnu.org> 1998", the original code can be

 *      found in the file hpfb.c in the same directory.

 *

 *      DECstation related code Copyright (C) 1999,2000,2001 by

 *      Michael Engel <engel@unix-ag.org> and

 *      Karsten Merker <merker@linuxtag.org>.

 *      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.

 *

 */

/*

 * Changes:

 * 2001-01-27  removed debugging and testing code, fixed fb_ops

 *             initialization which had caused a crash before,

 *             general cleanup, first official release (KM)

 *

 * 2003-03-08  Thiemo Seufer <seufer@csv.ica.uni-stuttgart.de>

 *             Moved ims332 support in its own file. Code cleanup.

 *

 * 2003-09-08  Thiemo Seufer <seufer@csv.ica.uni-stuttgart.de>

 *             First attempt of mono and hw cursor support.

 */

#include <linux/module.h>

#include <linux/kernel.h>

#include <linux/sched.h>

#include <linux/errno.h>

#include <linux/string.h>

#include <linux/mm.h>

#include <linux/tty.h>

#include <linux/slab.h>

#include <linux/delay.h>

#include <linux/timer.h>

#include <linux/init.h>

#include <linux/fb.h>

#include <linux/console.h>

/*

 * bootinfo.h is needed for checking whether we are really running

 * on a maxine.

 */

#include <asm/bootinfo.h>

#include <asm/addrspace.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 "ims332.h"

/* Version information */

#define DRIVER_VERSION "0.02"

#define DRIVER_AUTHOR "Karsten Merker <merker@linuxtag.org>"

#define DRIVER_DESCRIPTION "Maxine Framebuffer Driver"

#define DRIVER_DESCR "maxinefb"

/* Prototypes */

static int maxinefb_set_var(struct fb_var_screeninfo *var, int con,

                            struct fb_info *info);

/* Hardware cursor */

struct maxine_cursor {

        struct timer_list timer;

        int enable;

        int on;

        int vbl_cnt;

        int blink_rate;

        u16 x, y, width, height;

};

#define CURSOR_TIMER_FREQ       (HZ / 50)

#define CURSOR_BLINK_RATE       (20)

#define CURSOR_DRAW_DELAY       (2)

static struct maxinefb_info {

        struct fb_info info;

        struct display disp;

        struct display_switch dispsw;

        struct ims332_regs *ims332;

        unsigned long fb_start;

        u32 fb_size;

        struct maxine_cursor cursor;

} *my_info;

static struct maxinefb_par {

} current_par;

static int currcon = -1;

static void maxine_set_cursor(struct maxinefb_info *ip, int on)

{

        struct maxine_cursor *c = &ip->cursor;

        if (on)

                ims332_position_cursor(ip->ims332, c->x, c->y);

        ims332_enable_cursor(ip->ims332, on);

}

static void maxinefbcon_cursor(struct display *disp, int mode, int x, int y)

{

        struct maxinefb_info *ip = (struct maxinefb_info *)disp->fb_info;

        struct maxine_cursor *c = &ip->cursor;

        x *= fontwidth(disp);

        y *= fontheight(disp);

        if (c->x == x && c->y == y && (mode == CM_ERASE) == !c->enable)

                return;

        c->enable = 0;

        if (c->on)

                maxine_set_cursor(ip, 0);

        c->x = x - disp->var.xoffset;

        c->y = y - disp->var.yoffset;

        switch (mode) {

                case CM_ERASE:

                        c->on = 0;

                        break;

                case CM_DRAW:

                case CM_MOVE:

                        if (c->on)

                                maxine_set_cursor(ip, c->on);

                        else

                                c->vbl_cnt = CURSOR_DRAW_DELAY;

                        c->enable = 1;

                        break;

        }

}

static int maxinefbcon_set_font(struct display *disp, int width, int height)

{

        struct maxinefb_info *ip = (struct maxinefb_info *)disp->fb_info;

        struct maxine_cursor *c = &ip->cursor;

        u8 fgc = ~attr_bgcol_ec(disp, disp->conp);

        if (width > 64 || height > 64 || width < 0 || height < 0)

                return -EINVAL;

        c->height = height;

        c->width = width;

        ims332_set_font(ip->ims332, fgc, width, height);

        return 1;

}

static void maxine_cursor_timer_handler(unsigned long data)

{

        struct maxinefb_info *ip = (struct maxinefb_info *)data;

        struct maxine_cursor *c = &ip->cursor;

        if (!c->enable)

                goto out;

        if (c->vbl_cnt && --c->vbl_cnt == 0) {

                c->on ^= 1;

                maxine_set_cursor(ip, c->on);

                c->vbl_cnt = c->blink_rate;

        }

out:

        c->timer.expires = jiffies + CURSOR_TIMER_FREQ;

        add_timer(&c->timer);

}

static void __init maxine_cursor_init(struct maxinefb_info *ip)

{

        struct maxine_cursor *c = &ip->cursor;

        c->enable = 1;

        c->on = 1;

        c->x = c->y = 0;

        c->width = c->height = 0;

        c->vbl_cnt = CURSOR_DRAW_DELAY;

        c->blink_rate = CURSOR_BLINK_RATE;

        init_timer(&c->timer);

        c->timer.data = (unsigned long)ip;

        c->timer.function = maxine_cursor_timer_handler;

        mod_timer(&c->timer, jiffies + CURSOR_TIMER_FREQ);

}

static void __exit maxine_cursor_exit(struct maxinefb_info *ip)

{

        struct maxine_cursor *c = &ip->cursor;

        del_timer_sync(&c->timer);

}

#ifdef FBCON_HAS_MFB

extern void fbcon_mfb_clear_margins(struct vc_data *conp, struct display *p,

                                    int bottom_only);

static struct display_switch maxine_switch1 = {

        .setup = fbcon_mfb_setup,

        .bmove = fbcon_mfb_bmove,

        .clear = fbcon_mfb_clear,

        .putc = fbcon_mfb_putc,

        .putcs = fbcon_mfb_putcs,

        .revc = fbcon_mfb_revc,

        .cursor = maxinefbcon_cursor,

        .set_font = maxinefbcon_set_font,

        .clear_margins = fbcon_mfb_clear_margins,

        .fontwidthmask = FONTWIDTH(4)|FONTWIDTH(8)|FONTWIDTH(12)|FONTWIDTH(16)

};

#endif

#ifdef FBCON_HAS_CFB2

static struct display_switch maxine_switch2 = {

        .setup = fbcon_cfb2_setup,

        .bmove = fbcon_cfb2_bmove,

        .clear = fbcon_cfb2_clear,

        .putc = fbcon_cfb2_putc,

        .putcs = fbcon_cfb2_putcs,

        .revc = fbcon_cfb2_revc,

        .cursor = maxinefbcon_cursor,

        .set_font = maxinefbcon_set_font,

        .clear_margins = fbcon_cfb8_clear_margins, /* sigh.. */

        .fontwidthmask = FONTWIDTH(4)|FONTWIDTH(8)|FONTWIDTH(12)|FONTWIDTH(16)

};

#endif

#ifdef FBCON_HAS_CFB4

static struct display_switch maxine_switch4 = {

        .setup = fbcon_cfb4_setup,

        .bmove = fbcon_cfb4_bmove,

        .clear = fbcon_cfb4_clear,

        .putc = fbcon_cfb4_putc,

        .putcs = fbcon_cfb4_putcs,

        .revc = fbcon_cfb4_revc,

        .cursor = maxinefbcon_cursor,

        .set_font = maxinefbcon_set_font,

        .clear_margins = fbcon_cfb8_clear_margins, /* sigh.. */

        .fontwidthmask = FONTWIDTH(4)|FONTWIDTH(8)|FONTWIDTH(12)|FONTWIDTH(16)

};

#endif

static struct display_switch maxine_switch8 = {

        .setup = fbcon_cfb8_setup,

        .bmove = fbcon_cfb8_bmove,

        .clear = fbcon_cfb8_clear,

        .putc = fbcon_cfb8_putc,

        .putcs = fbcon_cfb8_putcs,

        .revc = fbcon_cfb8_revc,

        .cursor = maxinefbcon_cursor,

        .set_font = maxinefbcon_set_font,

        .clear_margins = fbcon_cfb8_clear_margins,

        .fontwidthmask = FONTWIDTH(4)|FONTWIDTH(8)|FONTWIDTH(12)|FONTWIDTH(16)

};

static void maxinefb_get_par(struct maxinefb_par *par)

{

        *par = current_par;

}

static int maxinefb_get_fix(struct fb_fix_screeninfo *fix, int con,

                            struct fb_info *info)

{

        struct maxinefb_info *ip = (struct maxinefb_info *)info;

        struct display *disp = (con < 0) ? &ip->disp : (fb_display + con);

        struct fb_var_screeninfo *var = &disp->var;

        memset(fix, 0, sizeof(struct fb_fix_screeninfo));

        strcpy(fix->id, DRIVER_DESCR);

        fix->smem_start = ip->fb_start;

        fix->smem_len = ip->fb_size;

        fix->type = FB_TYPE_PACKED_PIXELS;

        fix->ypanstep = 1;

        fix->ywrapstep = 1;

        fix->visual = FB_VISUAL_PSEUDOCOLOR;

        switch (var->bits_per_pixel) {

#ifdef FBCON_HAS_MFB

        case 1: fix->line_length = var->xres / 8; break;

#endif

#ifdef FBCON_HAS_CFB2

        case 2: fix->line_length = var->xres / 4; break;

#endif

#ifdef FBCON_HAS_CFB4

        case 4: fix->line_length = var->xres / 2; break;

#endif

        case 8:

        default:

                fix->line_length = var->xres;

                var->bits_per_pixel = 8;

                break;

        }

        fix->accel = FB_ACCEL_NONE;

        return 0;

}

static int maxinefb_set_dispsw(struct display *disp, struct maxinefb_info *ip)

{

        if (disp->conp && disp->conp->vc_sw && disp->conp->vc_sw->con_cursor)

                disp->conp->vc_sw->con_cursor(disp->conp, CM_ERASE);

        switch (disp->var.bits_per_pixel) {

#ifdef FBCON_HAS_MFB

        case 1: ip->dispsw = maxine_switch1; break;

#endif

#ifdef FBCON_HAS_CFB2

        case 2: ip->dispsw = maxine_switch2; break;

#endif

#ifdef FBCON_HAS_CFB4

        case 4: ip->dispsw = maxine_switch4; break;

#endif

        case 8:

        default:

                ip->dispsw = maxine_switch8;

                disp->var.bits_per_pixel = 8;

                break;

        }

        ims332_set_color_depth(ip->ims332, disp->var.bits_per_pixel);

        disp->dispsw = &ip->dispsw;

        disp->dispsw_data = 0;

        return 0;

}

static void maxinefb_set_disp(struct display *disp, int con,

                              struct maxinefb_info *ip)

{

        struct fb_fix_screeninfo fix;

        disp->fb_info = &ip->info;

        maxinefb_set_var(&disp->var, con, &ip->info);

        maxinefb_set_dispsw(disp, ip);

        maxinefb_get_fix(&fix, con, &ip->info);

        disp->screen_base = (u8 *)fix.smem_start;

        disp->visual = fix.visual;

        disp->type = fix.type;

        disp->type_aux = fix.type_aux;

        disp->ypanstep = fix.ypanstep;

        disp->ywrapstep = fix.ywrapstep;

        disp->line_length = fix.line_length;

        disp->next_line = fix.line_length;

        disp->can_soft_blank = 1;

        disp->inverse = 0;

        disp->scrollmode = SCROLL_YREDRAW;

        maxinefbcon_set_font(disp, fontwidth(disp), fontheight(disp));

}

static int getcolreg(u32 reg, u32 *red, u32 *green, u32 *blue, u32 *transp,

                     struct fb_info *info)

{

        struct maxinefb_info *ip = (struct maxinefb_info *)info;

        u8 r;

        u8 g;

        u8 b;

        if (reg > 255)

                return 1;

        /*

         * Cmap fields are 16 bits wide, but the hardware colormap

         * has only 8 bits.

         */

        ims332_read_cmap(ip->ims332, reg, &r, &g, &b);

        *red = r << 8;

        *green = g << 8;

        *blue = b << 8;

        *transp = 0;

        return 0;

}

static int setcolreg(u32 reg, u32 red, u32 green, u32 blue, u32 transp,

                     struct fb_info *info)

{

        struct maxinefb_info *ip = (struct maxinefb_info *)info;

        if (reg > 255)

                return 1;

        /*

         * Cmap fields are 16 bits wide, but the hardware colormap

         * has only 8 bits.

         */

        red = (red >> 8) & 0xff;

        green = (green >> 8) & 0xff;

        blue = (blue >> 8) & 0xff;

        ims332_write_cmap(ip->ims332, reg, red, green, blue);

        return 0;

}

#define CMAP_LEN(disp) ((disp->visual == FB_VISUAL_PSEUDOCOLOR) \

                        ? (1 << disp->var.bits_per_pixel) : 16)

static void do_install_cmap(int con, struct maxinefb_info *ip)

{

        struct display *disp = (con < 0) ? &ip->disp : (fb_display + con);

        int len = CMAP_LEN(disp);

        if (con != currcon)

                return;

        if (fb_display[con].cmap.len)

                fb_set_cmap(&fb_display[con].cmap, 1, setcolreg, &ip->info);

        else

                fb_set_cmap(fb_default_cmap(len), 1, setcolreg, &ip->info);

}

static void do_save_cmap(int con, struct maxinefb_info *ip)

{

        if (con != currcon)

                return;

        fb_get_cmap(&fb_display[con].cmap, 1, getcolreg, &ip->info);

}

static int maxinefb_get_cmap(struct fb_cmap *cmap, int kspc, int con,

                             struct fb_info *info)

{

        struct maxinefb_info *ip = (struct maxinefb_info *)info;

        struct display *disp = (con < 0) ? &ip->disp : (fb_display + con);

        int len = CMAP_LEN(disp);

        if (con == currcon) /* current console? */

                return fb_get_cmap(cmap, kspc, getcolreg, info);

        if (disp->cmap.len) /* non default colormap? */

                fb_copy_cmap(&disp->cmap, cmap, kspc ? 0 : 2);

        else

                fb_copy_cmap(fb_default_cmap(len), cmap, kspc ? 0 : 2);

        return 0;

}

static int maxinefb_set_cmap(struct fb_cmap *cmap, int kspc, int con,

                             struct fb_info *info)

{

        struct maxinefb_info *ip = (struct maxinefb_info *)info;

        struct display *disp = (con < 0) ? &ip->disp : (fb_display + con);

        int len = CMAP_LEN(disp);

        int err;

        /* No colormap allocated? */

        if ((err = fb_alloc_cmap(&disp->cmap, len, 0)))

                return err;

        if (con == currcon) /* current console? */

                return fb_set_cmap(cmap, kspc, setcolreg, info);

        fb_copy_cmap(cmap, &disp->cmap, kspc ? 0 : 1);

        return 0;

}

static int maxinefb_ioctl(struct inode *inode, struct file *file, u32 cmd,

                          unsigned long arg, int con, struct fb_info *info)

{

        /* TODO: Not yet implemented */

        return -ENOIOCTLCMD;

}

static int maxinefb_switch(int con, struct fb_info *info)

{

        struct maxinefb_info *ip = (struct maxinefb_info *)info;

        struct display *old = (currcon < 0) ? &ip->disp : (fb_display + currcon);

        struct display *new = (con < 0) ? &ip->disp : (fb_display + con);

        do_save_cmap(currcon, ip);

        if (old->conp && old->conp->vc_sw && old->conp->vc_sw->con_cursor)

                old->conp->vc_sw->con_cursor(old->conp, CM_ERASE);

        /* Set the current console. */

        currcon = con;

        maxinefb_set_disp(new, con, ip);

        return 0;

}

static int maxinefb_encode_var(struct fb_var_screeninfo *var,

                               struct maxinefb_par *par)

{

        var->xres = 1024;

        var->yres = 768;

        var->xres_virtual = 1024;

        var->yres_virtual = 1024;

        var->xoffset = 0;

        var->yoffset = 0;

        var->grayscale = 0;

        switch (var->bits_per_pixel) {

#ifdef FBCON_HAS_MFB

        case 1:

                var->red.offset = 0;

                var->red.length = 1;

                var->red.msb_right = 0;

                var->green.offset = 0;

                var->green.length = 1;

                var->green.msb_right = 0;

                var->blue.offset = 0;

                var->blue.length = 1;

                var->blue.msb_right = 0;

                var->transp.offset = 0;

                var->transp.length = 0;

                var->transp.msb_right = 0;

                break;

#endif

#ifdef FBCON_HAS_CFB2

        case 2:

                var->red.offset = 0;

                var->red.length = 2;

                var->red.msb_right = 0;

                var->green.offset = 0;

                var->green.length = 2;

                var->green.msb_right = 0;

                var->blue.offset = 0;

                var->blue.length = 2;

                var->blue.msb_right = 0;

                var->transp.offset = 0;

                var->transp.length = 0;

                var->transp.msb_right = 0;

                break;

#endif

#ifdef FBCON_HAS_CFB4

        case 4:

                var->red.offset = 0;

                var->red.length = 4;

                var->red.msb_right = 0;

                var->green.offset = 0;

                var->green.length = 4;

                var->green.msb_right = 0;

                var->blue.offset = 0;

                var->blue.length = 4;

                var->blue.msb_right = 0;

                var->transp.offset = 0;

                var->transp.length = 0;

                var->transp.msb_right = 0;

                break;

#endif

        case 8:

        default:

                var->red.offset = 0;

                var->red.length = 8;

                var->red.msb_right = 0;

                var->green.offset = 0;

                var->green.length = 8;

                var->green.msb_right = 0;

                var->blue.offset = 0;

                var->blue.length = 8;

                var->blue.msb_right = 0;

                var->transp.offset = 0;

                var->transp.length = 0;

                var->transp.msb_right = 0;

                var->bits_per_pixel = 8;

                break;

        }

        var->nonstd = 0;

        var->activate &= ~FB_ACTIVATE_MASK & FB_ACTIVATE_NOW;

        var->accel_flags = 0;

        var->sync = FB_SYNC_ON_GREEN;

        var->vmode &= ~FB_VMODE_MASK & FB_VMODE_NONINTERLACED;

        return 0;

}

static int maxinefb_get_var(struct fb_var_screeninfo *var, int con,

                            struct fb_info *info)

{

        struct maxinefb_par par;

        struct maxinefb_info *ip = (struct maxinefb_info *)info;

        struct display *disp = (con < 0) ? &ip->disp : (fb_display + con);

        if (con < 0) {

                maxinefb_get_par(&par);

                memset(var, 0, sizeof(struct fb_var_screeninfo));

                return maxinefb_encode_var(var, &par);

        } else

                *var = disp->var;

        return 0;

}

static int maxinefb_set_var(struct fb_var_screeninfo *var, int con,

                            struct fb_info *info)

{

        struct maxinefb_par par;

        struct maxinefb_info *ip = (struct maxinefb_info *)info;

        struct display *disp = (con < 0) ? &ip->disp : (fb_display + con);

        int ret;

        maxinefb_get_par(&par);

        ret = maxinefb_encode_var(var, &par);

        if (ret)

                goto out;

        disp->var = *var;

        /* Set default colormap. */

        ret = fb_alloc_cmap(&disp->cmap, 0, 0);

        if (ret)

                goto out;

        do_install_cmap(con, ip);

out:

        return ret;

}

static int maxinefb_fb_update_var(int con, struct fb_info *info)

{

        struct maxinefb_info *ip = (struct maxinefb_info *)info;

        struct display *disp = (con < 0) ? &ip->disp : (fb_display + con);

        if (con == currcon)

                maxinefbcon_cursor(disp, CM_ERASE, ip->cursor.x,

                                   ip->cursor.y);

        return 0;

}

/* 0 unblanks, anything else blanks. */

static void maxinefb_blank(int blank, struct fb_info *info)

{

        struct maxinefb_info *ip = (struct maxinefb_info *)info;

        ims332_blank_screen(ip->ims332, !!blank);

}

static struct fb_ops maxinefb_ops = {

        .owner = THIS_MODULE,

        .fb_get_fix = maxinefb_get_fix,