Subversion Repositories or1k

/*

 *      linux/drivers/video/pmag-ba-fb.c

 *

 *      PMAG-BA TurboChannel framebuffer card 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.

 *

 *      Based on digital document:

 *      "PMAG-BA TURBOchannel Color Frame Buffer

 *       Functional Specification", Revision 1.2, August 27, 1990

 *

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

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

 *      Karsten Merker <merker@linuxtag.org> and

 *      Harald Koerfgen.

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

 *

 */

#include <linux/module.h>

#include <linux/kernel.h>

#include <linux/sched.h>

#include <linux/errno.h>

#include <linux/string.h>

#include <linux/timer.h>

#include <linux/mm.h>

#include <linux/tty.h>

#include <linux/slab.h>

#include <linux/delay.h>

#include <linux/init.h>

#include <linux/fb.h>

#include <asm/bootinfo.h>

#include <asm/dec/machtype.h>

#include <asm/dec/tc.h>

#include "pmag-ba-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>

#define arraysize(x)    (sizeof(x)/sizeof(*(x)))

struct pmag_ba_ramdac_regs {

        unsigned char addr_low;

        unsigned char pad0[3];

        unsigned char addr_hi;

        unsigned char pad1[3];

        unsigned char data;

        unsigned char pad2[3];

        unsigned char cmap;

};

struct pmag_ba_my_fb_info {

        struct fb_info info;

        struct pmag_ba_ramdac_regs *bt459_regs;

        unsigned long pmagba_fb_start;

        unsigned long pmagba_fb_size;

        unsigned long pmagba_fb_line_length;

};

static struct display disp;

/*

 * Max 3 TURBOchannel slots -> max 3 PMAG-BA :)

 */

static struct pmag_ba_my_fb_info pmagba_fb_info[3];

static struct fb_var_screeninfo pmagbafb_defined = {

        0, 0, 0, 0,         /* W,H, W, H (virtual) load xres,xres_virtual */

        0, 0,                     /* virtual -> visible no offset */

        0,                       /* depth -> load bits_per_pixel */

        0,                       /* greyscale ? */

        {0, 0, 0},         /* R */

        {0, 0, 0},         /* G */

        {0, 0, 0},         /* B */

        {0, 0, 0},         /* transparency */

        0,                       /* standard pixel format */

        FB_ACTIVATE_NOW,

        274, 195,               /* 14" monitor */

        FB_ACCEL_NONE,

        0L, 0L, 0L, 0L, 0L,

        0L, 0L, 0,               /* No sync info */

        FB_VMODE_NONINTERLACED,

        {0, 0, 0, 0, 0, 0}

};

struct pmagbafb_par {

};

static int currcon = 0;

static struct pmagbafb_par current_par;

static void pmagbafb_encode_var(struct fb_var_screeninfo *var,

                                struct pmagbafb_par *par)

{

        int i = 0;

        var->xres = 1024;

        var->yres = 864;

        var->xres_virtual = 1024;

        var->yres_virtual = 864;

        var->xoffset = 0;

        var->yoffset = 0;

        var->bits_per_pixel = 8;

        var->grayscale = 0;

        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->nonstd = 0;

        var->activate = 1;

        var->height = -1;

        var->width = -1;

        var->vmode = FB_VMODE_NONINTERLACED;

        var->pixclock = 0;

        var->sync = 0;

        var->left_margin = 0;

        var->right_margin = 0;

        var->upper_margin = 0;

        var->lower_margin = 0;

        var->hsync_len = 0;

        var->vsync_len = 0;

        for (i = 0; i < arraysize(var->reserved); i++)

                var->reserved[i] = 0;

}

static void pmagbafb_get_par(struct pmagbafb_par *par)

{

        *par = current_par;

}

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

{

        return 0;

}

static int pmagba_do_fb_set_var(struct fb_var_screeninfo *var,

                                int isactive)

{

        struct pmagbafb_par par;

        pmagbafb_get_par(&par);

        pmagbafb_encode_var(var, &par);

        return 0;

}

/*

 * Turn hardware cursor off

 */

void pmagbafb_erase_cursor(struct pmag_ba_my_fb_info *info)

{

        info->bt459_regs->addr_low = 0;

        info->bt459_regs->addr_hi = 3;

        info->bt459_regs->data = 0;

}

/*

 * Write to a Bt459 color map register

 */

void pmag_ba_bt459_write_colormap(struct pmag_ba_my_fb_info *info,

                                  int reg, __u8 red, __u8 green, __u8 blue)

{

        info->bt459_regs->addr_low = (__u8) reg;

        info->bt459_regs->addr_hi = 0;

        info->bt459_regs->cmap = red;

        info->bt459_regs->cmap = green;

        info->bt459_regs->cmap = blue;

}

/*

 * Get the palette

 */

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

                             struct fb_info *info)

{

        unsigned int i;

        unsigned int length;

        if (((cmap->start) + (cmap->len)) >= 256) {

                length = 256 - (cmap->start);

        } else {

                length = cmap->len;

        }

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

                /*

                 * TODO

                 */

        }

        return 0;

}

/*

 * Set the palette.

 */

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

                             struct fb_info *info)

{

        unsigned int i;

        __u8 cmap_red, cmap_green, cmap_blue;

        unsigned int length;

        if (((cmap->start) + (cmap->len)) >= 256)

                length = 256 - (cmap->start);

        else

                length = cmap->len;

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

                cmap_red = ((cmap->red[i]) >> 8);       /* The cmap fields are 16 bits    */

                cmap_green = ((cmap->green[i]) >> 8);   /* wide, but the harware colormap */

                cmap_blue = ((cmap->blue[i]) >> 8);     /* registers are only 8 bits wide */

                pmag_ba_bt459_write_colormap((struct pmag_ba_my_fb_info *)

                                             info, cmap->start + i,

                                             cmap_red, cmap_green,

                                             cmap_blue);

        }

        return 0;

}

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

                            struct fb_info *info)

{

        struct pmagbafb_par par;

        if (con == -1) {

                pmagbafb_get_par(&par);

                pmagbafb_encode_var(var, &par);

        } else

                *var = fb_display[con].var;

        return 0;

}

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

                            struct fb_info *info)

{

        int err;

        if ((err = pmagba_do_fb_set_var(var, 1)))

                return err;

        return 0;

}

static void pmagbafb_encode_fix(struct fb_fix_screeninfo *fix,

                                struct pmagbafb_par *par,

                                struct pmag_ba_my_fb_info *info)

{

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

        strcpy(fix->id, "PMAG-BA");

        fix->smem_start = info->pmagba_fb_start;

        fix->smem_len = info->pmagba_fb_size;

        fix->type = FB_TYPE_PACKED_PIXELS;

        fix->visual = FB_VISUAL_PSEUDOCOLOR;

        fix->xpanstep = 0;

        fix->ypanstep = 0;

        fix->ywrapstep = 0;

        fix->line_length = info->pmagba_fb_line_length;

}

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

                            struct fb_info *info)

{

        struct pmagbafb_par par;

        pmagbafb_get_par(&par);

        pmagbafb_encode_fix(fix, &par, (struct pmag_ba_my_fb_info *) info);

        return 0;

}

static int pmagbafb_ioctl(struct inode *inode, struct file *file,

                          unsigned int cmd, unsigned long arg, int con,

                          struct fb_info *info)

{

        return -EINVAL;

}

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

{

        pmagba_do_fb_set_var(&fb_display[con].var, 1);

        currcon = con;

        return 0;

}

/* 0 unblank, 1 blank, 2 no vsync, 3 no hsync, 4 off */

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

{

        /* Not supported */

}

static int pmagbafb_open(struct fb_info *info, int user)

{

        /*

         * Nothing, only a usage count for the moment

         */

        MOD_INC_USE_COUNT;

        return (0);

}

static void pmagbafb_set_disp(int con, struct pmag_ba_my_fb_info *info)

{

        struct fb_fix_screeninfo fix;

        struct display *display;

        if (con >= 0)

                display = &fb_display[con];

        else

                display = &disp;        /* used during initialization */

        pmagbafb_get_fix(&fix, con, (struct fb_info *) info);

        display->screen_base = (char *) fix.smem_start;

        display->visual = fix.visual;

        display->type = fix.type;

        display->type_aux = fix.type_aux;

        display->ypanstep = fix.ypanstep;

        display->ywrapstep = fix.ywrapstep;

        display->line_length = fix.line_length;

        display->next_line = fix.line_length;

        display->can_soft_blank = 0;

        display->inverse = 0;

        display->scrollmode = SCROLL_YREDRAW;

        display->dispsw = &fbcon_cfb8;

}

static int pmagbafb_release(struct fb_info *info, int user)

{

        MOD_DEC_USE_COUNT;

        return (0);

}

static struct fb_ops pmagbafb_ops = {

        owner:THIS_MODULE,

        fb_open:pmagbafb_open,

        fb_release:pmagbafb_release,

        fb_get_fix:pmagbafb_get_fix,

        fb_get_var:pmagbafb_get_var,

        fb_set_var:pmagbafb_set_var,

        fb_get_cmap:pmagbafb_get_cmap,

        fb_set_cmap:pmagbafb_set_cmap,

        fb_ioctl:pmagbafb_ioctl,

        fb_mmap:0,

        fb_rasterimg:0

};

int __init pmagbafb_init_one(int slot)

{

        unsigned long base_addr = get_tc_base_addr(slot);

        struct pmag_ba_my_fb_info *ip =

            (struct pmag_ba_my_fb_info *) &pmagba_fb_info[slot];

        printk("PMAG-BA framebuffer in slot %d\n", slot);

        /*

         * Framebuffer display memory base address and friends

         */

        ip->bt459_regs =

            (struct pmag_ba_ramdac_regs *) (base_addr +

                                            PMAG_BA_BT459_OFFSET);

        ip->pmagba_fb_start = base_addr + PMAG_BA_ONBOARD_FBMEM_OFFSET;

        ip->pmagba_fb_size = 1024 * 864;

        ip->pmagba_fb_line_length = 1024;

        /*

         * Configure the Bt459 RAM DAC

         */

        pmagbafb_erase_cursor(ip);

        /*

         *      Fill in the available video resolution

         */

        pmagbafb_defined.xres = 1024;

        pmagbafb_defined.yres = 864;

        pmagbafb_defined.xres_virtual = 1024;

        pmagbafb_defined.yres_virtual = 864;

        pmagbafb_defined.bits_per_pixel = 8;

        /*

         *      Let there be consoles..

         */

        strcpy(ip->info.modename, "PMAG-BA");

        ip->info.changevar = NULL;

        ip->info.node = -1;

        ip->info.fbops = &pmagbafb_ops;

        ip->info.disp = &disp;

        ip->info.switch_con = &pmagbafb_switch;

        ip->info.updatevar = &pmagba_fb_update_var;

        ip->info.blank = &pmagbafb_blank;

        ip->info.flags = FBINFO_FLAG_DEFAULT;

        pmagba_do_fb_set_var(&pmagbafb_defined, 1);

        pmagbafb_get_var(&disp.var, -1, (struct fb_info *) ip);

        pmagbafb_set_disp(-1, ip);

        if (register_framebuffer((struct fb_info *) ip) < 0)

                return 1;

        return 0;

}

/*

 * Initialise the framebuffer

 */

int __init pmagbafb_init(void)

{

        int sid;

        int found = 0;

        if (TURBOCHANNEL) {

                while ((sid = search_tc_card("PMAG-BA")) >= 0) {

                        found = 1;

                        claim_tc_card(sid);

                        pmagbafb_init_one(sid);

                }

                return found ? 0 : -ENODEV;

        } else {

                return -ENODEV;

        }

}

MODULE_LICENSE("GPL");