Subversion Repositories or1k

/*

 * linux/arch/m68k/amiga/cyberfb.c -- Low level implementation of the

 *                                    Cybervision frame buffer device

 *

 *    Copyright (C) 1996 Martin Apel

 *                       Geert Uytterhoeven

 *

 *

 * This file is based on the Amiga frame buffer device (amifb.c):

 *

 *    Copyright (C) 1995 Geert Uytterhoeven

 *

 *

 * History:

 *   - 22 Dec 95: Original version by Martin Apel

 *   - 05 Jan 96: Geert: integration into the current source tree

 *

 *

 * 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/kernel.h>

#include <linux/errno.h>

#include <linux/string.h>

#include <linux/mm.h>

#include <linux/tty.h>

#include <linux/malloc.h>

#include <linux/delay.h>

#include <asm/segment.h>

#include <asm/system.h>

#include <asm/irq.h>

#include <asm/bootinfo.h>

#include <asm/zorro.h>

#include <asm/pgtable.h>

#include <linux/fb.h>

#include "s3blit.h"

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

struct Cyber_fb_par {

   int xres;

   int yres;

   int bpp;

};

static struct Cyber_fb_par current_par;

static int current_par_valid = 0;

static int currcon = 0;

static struct display disp[MAX_NR_CONSOLES];

static struct fb_info fb_info;

static int node;        /* node of the /dev/fb?current file */

   /*

    *    Switch for Chipset Independency

    */

static struct fb_hwswitch {

   /* Initialisation */

   int (*init)(void);

   /* Display Control */

   int (*encode_fix)(struct fb_fix_screeninfo *fix, struct Cyber_fb_par *par);

   int (*decode_var)(struct fb_var_screeninfo *var, struct Cyber_fb_par *par);

   int (*encode_var)(struct fb_var_screeninfo *var, struct Cyber_fb_par *par);

   int (*getcolreg)(u_int regno, u_int *red, u_int *green, u_int *blue,

                    u_int *transp);

   int (*setcolreg)(u_int regno, u_int red, u_int green, u_int blue,

                    u_int transp);

   void (*blank)(int blank);

} *fbhw;

   /*

    *    Frame Buffer Name

    */

static char Cyber_fb_name[16] = "Cybervision";

   /*

    *    Cybervision Graphics Board

    */

#define CYBER8_WIDTH 1152

#define CYBER8_HEIGHT 886

#define CYBER8_PIXCLOCK 12500    /* ++Geert: Just a guess */

#define CYBER16_WIDTH 800

#define CYBER16_HEIGHT 600

#define CYBER16_PIXCLOCK 25000   /* ++Geert: Just a guess */

static int CyberKey = 0;

static u_char Cyber_colour_table [256][4];

static unsigned long CyberMem;

static unsigned long CyberSize;

static volatile char *CyberRegs;

static long *memstart;

   /*

    *    Predefined Video Mode Names

    */

static char *Cyber_fb_modenames[] = {

   /*

    *    Autodetect (Default) Video Mode

    */

   "default",

   /*

    *    Predefined Video Modes

    */

   "cyber8",            /* Cybervision 8 bpp */

   "cyber16",           /* Cybervision 16 bpp */

   /*

    *    Dummy Video Modes

    */

   "dummy", "dummy", "dummy", "dummy", "dummy", "dummy", "dummy", "dummy",

   "dummy", "dummy", "dummy", "dummy", "dummy", "dummy", "dummy", "dummy",

   "dummy", "dummy", "dummy", "dummy",

   /*

    *    User Defined Video Modes

    *

    *    This doesn't work yet!!

    */

   "user0", "user1", "user2", "user3", "user4", "user5", "user6", "user7"

};

   /*

    *    Predefined Video Mode Definitions

    */

static struct fb_var_screeninfo Cyber_fb_predefined[] = {

   /*

    *    Autodetect (Default) Video Mode

    */

   { 0, },

   /*

    *    Predefined Video Modes

    */

   {

      /* Cybervision 8 bpp */

      CYBER8_WIDTH, CYBER8_HEIGHT, CYBER8_WIDTH, CYBER8_HEIGHT, 0, 0, 8, 0,

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

      0, 0, -1, -1, FB_ACCEL_NONE, CYBER8_PIXCLOCK, 64, 96, 35, 12, 112, 2,

      FB_SYNC_COMP_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED

   }, {

      /* Cybervision 16 bpp */

      CYBER16_WIDTH, CYBER16_HEIGHT, CYBER16_WIDTH, CYBER16_HEIGHT, 0, 0, 16, 0,

      {11, 5, 0}, {5, 6, 0}, {0, 5, 0}, {0, 0, 0},

      0, 0, -1, -1, FB_ACCEL_NONE, CYBER16_PIXCLOCK, 64, 96, 35, 12, 112, 2,

      FB_SYNC_COMP_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED

   },

   /*

    *    Dummy Video Modes

    */

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

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

   { 0, }, { 0, },

   /*

    *    User Defined Video Modes

    */

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

};

#define NUM_TOTAL_MODES    arraysize(Cyber_fb_predefined)

#define NUM_PREDEF_MODES   (3)

static int Cyberfb_inverse = 0;

static int Cyberfb_Cyber8 = 0;        /* Use Cybervision board */

static int Cyberfb_Cyber16 = 0;       /* Use Cybervision board */

static int Cyberfb_mode = 0;

   /*

    *    Some default modes

    */

#define CYBER8_DEFMODE     (1)

#define CYBER16_DEFMODE    (2)

   /*

    *    Interface used by the world

    */

int Cyber_probe(void);

void Cyber_video_setup(char *options, int *ints);

static int Cyber_fb_get_fix(struct fb_fix_screeninfo *fix, int con);

static int Cyber_fb_get_var(struct fb_var_screeninfo *var, int con);

static int Cyber_fb_set_var(struct fb_var_screeninfo *var, int con);

static int Cyber_fb_get_cmap(struct fb_cmap *cmap, int kspc, int con);

static int Cyber_fb_set_cmap(struct fb_cmap *cmap, int kspc, int con);

static int Cyber_fb_pan_display(struct fb_var_screeninfo *var, int con);

static int Cyber_fb_ioctl(struct inode *inode, struct file *file, u_int cmd,

                          u_long arg, int con);

   /*

    *    Interface to the low level console driver

    */

struct fb_info *Cyber_fb_init(long *mem_start); /* Through amiga_fb_init() */

static int Cyberfb_switch(int con);

static int Cyberfb_updatevar(int con);

static void Cyberfb_blank(int blank);

   /*

    *    Accelerated Functions used by the low level console driver

    */

void Cyber_WaitQueue(u_short fifo);

void Cyber_WaitBlit(void);

void Cyber_BitBLT(u_short curx, u_short cury, u_short destx, u_short desty,

                  u_short width, u_short height, u_short mode);

void Cyber_RectFill(u_short x, u_short y, u_short width, u_short height,

                    u_short mode, u_short color);

void Cyber_MoveCursor(u_short x, u_short y);

   /*

    *   Hardware Specific Routines

    */

static int Cyber_init(void);

static int Cyber_encode_fix(struct fb_fix_screeninfo *fix,

                          struct Cyber_fb_par *par);

static int Cyber_decode_var(struct fb_var_screeninfo *var,

                          struct Cyber_fb_par *par);

static int Cyber_encode_var(struct fb_var_screeninfo *var,

                          struct Cyber_fb_par *par);

static int Cyber_getcolreg(u_int regno, u_int *red, u_int *green, u_int *blue,

                         u_int *transp);

static int Cyber_setcolreg(u_int regno, u_int red, u_int green, u_int blue,

                         u_int transp);

static void Cyber_blank(int blank);

   /*

    *    Internal routines

    */

static void Cyber_fb_get_par(struct Cyber_fb_par *par);

static void Cyber_fb_set_par(struct Cyber_fb_par *par);

static int do_fb_set_var(struct fb_var_screeninfo *var, int isactive);

static struct fb_cmap *get_default_colormap(int bpp);

static int do_fb_get_cmap(struct fb_cmap *cmap, struct fb_var_screeninfo *var,

                          int kspc);

static int do_fb_set_cmap(struct fb_cmap *cmap, struct fb_var_screeninfo *var,

                          int kspc);

static void do_install_cmap(int con);

static void memcpy_fs(int fsfromto, void *to, void *from, int len);

static void copy_cmap(struct fb_cmap *from, struct fb_cmap *to, int fsfromto);

static int alloc_cmap(struct fb_cmap *cmap, int len, int transp);

static void Cyber_fb_set_disp(int con);

static int get_video_mode(const char *name);

/* -------------------- Hardware specific routines -------------------------- */

   /*

    *    Initialization

    *

    *    Set the default video mode for this chipset. If a video mode was

    *    specified on the command line, it will override the default mode.

    */

static int Cyber_init(void)

{

int i;

char size;

volatile u_long *CursorBase;

unsigned long board_addr;

struct ConfigDev *cd;

if (Cyberfb_mode == -1)

  {

  if (Cyberfb_Cyber8)

    Cyberfb_mode = CYBER8_DEFMODE;

  else

    Cyberfb_mode = CYBER16_DEFMODE;

  }

cd = zorro_get_board (CyberKey);

zorro_config_board (CyberKey, 0);

board_addr = (unsigned long)cd->cd_BoardAddr;

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

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

  {

  Cyber_colour_table [i][0] = i;

  Cyber_colour_table [i][1] = i;

  Cyber_colour_table [i][2] = i;

  Cyber_colour_table [i][3] = 0;

  }

*memstart = (*memstart + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1);

CyberMem = kernel_map (board_addr + 0x01400000, 0x00400000,

                       KERNELMAP_NOCACHE_SER, memstart);

if (Cyberfb_Cyber8)

  memset ((char*)CyberMem, 0, CYBER8_WIDTH * CYBER8_HEIGHT);

else

  memset ((char*)CyberMem, 0, CYBER16_WIDTH * CYBER16_HEIGHT);

CyberRegs = (char*) kernel_map (board_addr + 0x02000000, 0xf000,

                                KERNELMAP_NOCACHE_SER, memstart);

/* Disable hardware cursor */

*(CyberRegs + S3_CRTC_ADR)  = S3_REG_LOCK2;

*(CyberRegs + S3_CRTC_DATA) = 0xa0;

*(CyberRegs + S3_CRTC_ADR)  = S3_HGC_MODE;

*(CyberRegs + S3_CRTC_DATA) = 0x00;

*(CyberRegs + S3_CRTC_ADR)  = S3_HWGC_DX;

*(CyberRegs + S3_CRTC_DATA) = 0x00;

*(CyberRegs + S3_CRTC_ADR)  = S3_HWGC_DY;

*(CyberRegs + S3_CRTC_DATA) = 0x00;

/* Set clipping rectangle to current screen size */

*((u_short volatile *)(CyberRegs + 0xbee8)) = 0x1000;

*((u_short volatile *)(CyberRegs + 0xbee8)) = 0x2000;

if (Cyberfb_Cyber8)

  {

  *((u_short volatile *)(CyberRegs + 0xbee8)) = 0x3000 | (CYBER8_HEIGHT - 1);

  *((u_short volatile *)(CyberRegs + 0xbee8)) = 0x4000 | (CYBER8_WIDTH - 1);

  }

else

  {

  *((u_short volatile *)(CyberRegs + 0xbee8)) = 0x3000 | (CYBER16_HEIGHT - 1);

  *((u_short volatile *)(CyberRegs + 0xbee8)) = 0x4000 | (CYBER16_WIDTH - 1);

  }

/* Get memory size (if not 2MB it is 4MB) */

*(CyberRegs + S3_CRTC_ADR) = S3_LAW_CTL;

size = *(CyberRegs + S3_CRTC_DATA);

if ((size & 0x03) == 0x02)

  CyberSize = 0x00200000; /* 2 MB */

else

  CyberSize = 0x00400000; /* 4 MB */

/* Initialize hardware cursor */

CursorBase = (u_long *)((char *)(CyberMem) + CyberSize - 0x400);

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

  {

  *(CursorBase  +(i*4)) = 0xffffff00;

  *(CursorBase+1+(i*4)) = 0xffff0000;

  *(CursorBase+2+(i*4)) = 0xffff0000;

  *(CursorBase+3+(i*4)) = 0xffff0000;

  }

for (i=8; i < 64; i++)

  {

  *(CursorBase  +(i*4)) = 0xffff0000;

  *(CursorBase+1+(i*4)) = 0xffff0000;

  *(CursorBase+2+(i*4)) = 0xffff0000;

  *(CursorBase+3+(i*4)) = 0xffff0000;

  }

Cyber_setcolreg (255, 56, 100, 160, 0);

Cyber_setcolreg (254, 0, 0, 0, 0);

return (0);

}

   /*

    *    This function should fill in the `fix' structure based on the

    *    values in the `par' structure.

    */

static int Cyber_encode_fix(struct fb_fix_screeninfo *fix,

                          struct Cyber_fb_par *par)

{

   int i;

   strcpy(fix->id, Cyber_fb_name);

   fix->smem_start = CyberMem;

   fix->smem_len = CyberSize;

   fix->type = FB_TYPE_PACKED_PIXELS;

   fix->type_aux = 0;

   if (par->bpp == 8)

      fix->visual = FB_VISUAL_PSEUDOCOLOR;

   else

      fix->visual = FB_VISUAL_DIRECTCOLOR;

   fix->xpanstep = 0;

   fix->ypanstep = 0;

   fix->ywrapstep = 0;

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

      fix->reserved[i] = 0;

   return(0);

}

   /*

    *    Get the video params out of `var'. If a value doesn't fit, round

    *    it up, if it's too big, return -EINVAL.

    */

static int Cyber_decode_var(struct fb_var_screeninfo *var,

                          struct Cyber_fb_par *par)

{

   if (Cyberfb_Cyber8) {

      par->xres = CYBER8_WIDTH;

      par->yres = CYBER8_HEIGHT;

      par->bpp = 8;

   } else {

      par->xres = CYBER16_WIDTH;

      par->yres = CYBER16_HEIGHT;

      par->bpp = 16;

   }

   return(0);

}

   /*

    *    Fill the `var' structure based on the values in `par' and maybe

    *    other values read out of the hardware.

    */

static int Cyber_encode_var(struct fb_var_screeninfo *var,

                          struct Cyber_fb_par *par)

{

   int i;

   var->xres = par->xres;

   var->yres = par->yres;

   var->xres_virtual = par->xres;

   var->yres_virtual = par->yres;

   var->xoffset = 0;

   var->yoffset = 0;

   var->bits_per_pixel = par->bpp;

   var->grayscale = 0;

   if (par->bpp == 8) {

      var->red.offset = 0;

      var->red.length = 8;

      var->red.msb_right = 0;

      var->blue = var->green = var->red;

   } else {

      var->red.offset = 11;

      var->red.length = 5;

      var->red.msb_right = 0;

      var->green.offset = 5;

      var->green.length = 6;

      var->green.msb_right = 0;

      var->blue.offset = 0;

      var->blue.length = 5;

      var->blue.msb_right = 0;

   }

   var->transp.offset = 0;

   var->transp.length = 0;

   var->transp.msb_right = 0;

   var->nonstd = 0;

   var->activate = 0;

   var->height = -1;

   var->width = -1;

   var->accel = FB_ACCEL_CYBERVISION;

   var->vmode = FB_VMODE_NONINTERLACED;

   /* Dummy values */

   if (par->bpp == 8)

      var->pixclock = CYBER8_PIXCLOCK;

   else

      var->pixclock = CYBER16_PIXCLOCK;

   var->sync = 0;

   var->left_margin = 64;

   var->right_margin = 96;

   var->upper_margin = 35;

   var->lower_margin = 12;

   var->hsync_len = 112;

   var->vsync_len = 2;

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

      var->reserved[i] = 0;

   return(0);

}

   /*

    *    Set a single color register. The values supplied are already

    *    rounded down to the hardware's capabilities (according to the

    *    entries in the var structure). Return != 0 for invalid regno.

    */

static int Cyber_setcolreg(u_int regno, u_int red, u_int green, u_int blue,

                         u_int transp)

{

if (regno > 255)

  return (1);

*(CyberRegs + 0x3c8) = (char)regno;

Cyber_colour_table [regno][0] = red & 0xff;

Cyber_colour_table [regno][1] = green & 0xff;

Cyber_colour_table [regno][2] = blue & 0xff;

Cyber_colour_table [regno][3] = transp;

*(CyberRegs + 0x3c9) = (red & 0xff) >> 2;

*(CyberRegs + 0x3c9) = (green & 0xff) >> 2;

*(CyberRegs + 0x3c9) = (blue & 0xff) >> 2;

return (0);

}

   /*

    *    Read a single color register and split it into

    *    colors/transparent. Return != 0 for invalid regno.

    */

static int Cyber_getcolreg(u_int regno, u_int *red, u_int *green, u_int *blue,

                         u_int *transp)

{

if (regno >= 256)

  return (1);

*red    = Cyber_colour_table [regno][0];

*green  = Cyber_colour_table [regno][1];

*blue   = Cyber_colour_table [regno][2];

*transp = Cyber_colour_table [regno][3];

return (0);

}

   /*

    *    (Un)Blank the screen

    */

void Cyber_blank(int blank)

{

int i;

if (blank)

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

    {

    *(CyberRegs + 0x3c8) = i;

    *(CyberRegs + 0x3c9) = 0;

    *(CyberRegs + 0x3c9) = 0;

    *(CyberRegs + 0x3c9) = 0;

    }

else

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

    {

    *(CyberRegs + 0x3c8) = i;

    *(CyberRegs + 0x3c9) = Cyber_colour_table [i][0] >> 2;

    *(CyberRegs + 0x3c9) = Cyber_colour_table [i][1] >> 2;

    *(CyberRegs + 0x3c9) = Cyber_colour_table [i][2] >> 2;

    }

}

/**************************************************************

 * We are waiting for "fifo" FIFO-slots empty

 */

void Cyber_WaitQueue (u_short fifo)

{

u_short status;

do

  {

  status = *((u_short volatile *)(CyberRegs + S3_GP_STAT));

  }

while (status & fifo);

}

/**************************************************************

 * We are waiting for Hardware (Graphics Engine) not busy

 */

void Cyber_WaitBlit (void)

{

u_short status;

do

  {

  status = *((u_short volatile *)(CyberRegs + S3_GP_STAT));

  }

while (status & S3_HDW_BUSY);

}

/**************************************************************

 * BitBLT - Through the Plane

 */

void Cyber_BitBLT (u_short curx, u_short cury, u_short destx, u_short desty,

                   u_short width, u_short height, u_short mode)

{

u_short blitcmd = S3_BITBLT;

/* Set drawing direction */