drivers/video/fm2fb.c

   1 /*
   2  *  linux/drivers/video/fm2fb.c -- BSC FrameMaster II/Rainbow II frame buffer
   3  *                                 device
   4  *
   5  *      Copyright (C) 1998 Steffen A. Mork (mork@ls7.cs.uni-dortmund.de)
   6  *      Copyright (C) 1999 Geert Uytterhoeven
   7  *
   8  *  Written for 2.0.x by Steffen A. Mork
   9  *  Ported to 2.1.x by Geert Uytterhoeven
  10  *
  11  *  This file is subject to the terms and conditions of the GNU General Public
  12  *  License. See the file COPYING in the main directory of this archive for
  13  *  more details.
  14  */
  15
  16 #include <linux/module.h>
  17 #include <linux/mm.h>
  18 #include <linux/fb.h>
  19 #include <linux/init.h>
  20 #include <linux/zorro.h>
  21
  22 #include <asm/io.h>
  23
  24 #include <video/fbcon.h>
  25 #include <video/fbcon-cfb32.h>
  26
  27
  28 /*
  29  *      Some technical notes:
  30  *
  31  *      The BSC FrameMaster II (or Rainbow II) is a simple very dumb
  32  *      frame buffer which allows to display 24 bit true color images.
  33  *      Each pixel is 32 bit width so it's very easy to maintain the
  34  *      frame buffer. One long word has the following layout:
  35  *      AARRGGBB which means: AA the alpha channel byte, RR the red
  36  *      channel, GG the green channel and BB the blue channel.
  37  *
  38  *      The FrameMaster II supports the following video modes.
  39  *      - PAL/NTSC
  40  *      - interlaced/non interlaced
  41  *      - composite sync/sync/sync over green
  42  *
  43  *      The resolution is to the following both ones:
  44  *      - 768x576 (PAL)
  45  *      - 768x480 (NTSC)
  46  *
  47  *      This means that pixel access per line is fixed due to the
  48  *      fixed line width. In case of maximal resolution the frame
  49  *      buffer needs an amount of memory of 1.769.472 bytes which
  50  *      is near to 2 MByte (the allocated address space of Zorro2).
  51  *      The memory is channel interleaved. That means every channel
  52  *      owns four VRAMs. Unfortunatly most FrameMasters II are
  53  *      not assembled with memory for the alpha channel. In this
  54  *      case it could be possible to add the frame buffer into the
  55  *      normal memory pool.
  56  *
  57  *      At relative address 0x1ffff8 of the frame buffers base address
  58  *      there exists a control register with the number of
  59  *      four control bits. They have the following meaning:
  60  *      bit value meaning
  61  *
  62  *       0    1   0=interlaced/1=non interlaced
  63  *       1    2   0=video out disabled/1=video out enabled
  64  *       2    4   0=normal mode as jumpered via JP8/1=complement mode
  65  *       3    8   0=read  onboard ROM/1 normal operation (required)
  66  *
  67  *      As mentioned above there are several jumper. I think there
  68  *      is not very much information about the FrameMaster II in
  69  *      the world so I add these information for completeness.
  70  *
  71  *      JP1  interlace selection (1-2 non interlaced/2-3 interlaced)
  72  *      JP2  wait state creation (leave as is!)
  73  *      JP3  wait state creation (leave as is!)
  74  *      JP4  modulate composite sync on green output (1-2 composite
  75  *           sync on green channel/2-3 normal composite sync)
  76  *      JP5  create test signal, shorting this jumper will create
  77  *           a white screen
  78  *      JP6  sync creation (1-2 composite sync/2-3 H-sync output)
  79  *      JP8  video mode (1-2 PAL/2-3 NTSC)
  80  *
  81  *      With the following jumpering table you can connect the
  82  *      FrameMaster II to a normal TV via SCART connector:
  83  *      JP1:  2-3
  84  *      JP4:  2-3
  85  *      JP6:  2-3
  86  *      JP8:  1-2 (means PAL for Europe)
  87  *
  88  *      NOTE:
  89  *      There is no other possibility to change the video timings
  90  *      except the interlaced/non interlaced, sync control and the
  91  *      video mode PAL (50 Hz)/NTSC (60 Hz). Inside this
  92  *      FrameMaster II driver are assumed values to avoid anomalies
  93  *      to a future X server. Except the pixel clock is really
  94  *      constant at 30 MHz.
  95  *
  96  *      9 pin female video connector:
  97  *
  98  *      1  analog red 0.7 Vss
  99  *      2  analog green 0.7 Vss
 100  *      3  analog blue 0.7 Vss
 101  *      4  H-sync TTL
 102  *      5  V-sync TTL
 103  *      6  ground
 104  *      7  ground
 105  *      8  ground
 106  *      9  ground
 107  *
 108  *      Some performance notes:
 109  *      The FrameMaster II was not designed to display a console
 110  *      this driver would do! It was designed to display still true
 111  *      color images. Imagine: When scroll up a text line there
 112  *      must copied ca. 1.7 MBytes to another place inside this
 113  *      frame buffer. This means 1.7 MByte read and 1.7 MByte write
 114  *      over the slow 16 bit wide Zorro2 bus! A scroll of one
 115  *      line needs 1 second so do not expect to much from this
 116  *      driver - he is at the limit!
 117  *
 118  */
 119
 120
 121 /*
 122  *      definitions
 123  */
 124
 125 #define FRAMEMASTER_SIZE        0x200000
 126 #define FRAMEMASTER_REG         0x1ffff8
 127
 128 #define FRAMEMASTER_NOLACE      1
 129 #define FRAMEMASTER_ENABLE      2
 130 #define FRAMEMASTER_COMPL       4
 131 #define FRAMEMASTER_ROM         8
 132
 133
 134 struct FrameMaster_fb_par
 135 {
 136         int xres;
 137         int yres;
 138         int bpp;
 139         int pixclock;
 140 };
 141
 142 static unsigned long fm2fb_mem_phys;
 143 static void *fm2fb_mem;
 144 static unsigned long fm2fb_reg_phys;
 145 static volatile unsigned char *fm2fb_reg;
 146
 147 static int currcon = 0;
 148 static struct display disp;
 149 static struct fb_info fb_info;
 150 static struct { u_char red, green, blue, pad; } palette[16];
 151 #ifdef FBCON_HAS_CFB32
 152 static u32 fbcon_cfb32_cmap[16];
 153 #endif
 154
 155 static struct fb_fix_screeninfo fb_fix;
 156 static struct fb_var_screeninfo fb_var;
 157
 158 static int fm2fb_mode __initdata = -1;
 159
 160 #define FM2FB_MODE_PAL  0
 161 #define FM2FB_MODE_NTSC 1
 162
 163 static struct fb_var_screeninfo fb_var_modes[] __initdata = {
 164     {
 165         /* 768 x 576, 32 bpp (PAL) */
 166         768, 576, 768, 576, 0, 0, 32, 0,
 167         { 16, 8, 0 }, { 8, 8, 0 }, { 0, 8, 0 }, { 24, 8, 0 },
 168         0, FB_ACTIVATE_NOW, -1, -1, FB_ACCEL_NONE,
 169         33333, 10, 102, 10, 5, 80, 34, FB_SYNC_COMP_HIGH_ACT, 0
 170     }, {
 171         /* 768 x 480, 32 bpp (NTSC - not supported yet */
 172         768, 480, 768, 480, 0, 0, 32, 0,
 173         { 16, 8, 0 }, { 8, 8, 0 }, { 0, 8, 0 }, { 24, 8, 0 },
 174         0, FB_ACTIVATE_NOW, -1, -1, FB_ACCEL_NONE,
 175         33333, 10, 102, 10, 5, 80, 34, FB_SYNC_COMP_HIGH_ACT, 0
 176     }
 177 };
 178
 179
 180     /*
 181      *  Interface used by the world
 182      */
 183
 184 static int fm2fb_get_fix(struct fb_fix_screeninfo *fix, int con,
 185                          struct fb_info *info);
 186 static int fm2fb_get_var(struct fb_var_screeninfo *var, int con,
 187                          struct fb_info *info);
 188 static int fm2fb_set_var(struct fb_var_screeninfo *var, int con,
 189                          struct fb_info *info);
 190 static int fm2fb_get_cmap(struct fb_cmap *cmap, int kspc, int con,
 191                           struct fb_info *info);
 192 static int fm2fb_set_cmap(struct fb_cmap *cmap, int kspc, int con,
 193                           struct fb_info *info);
 194
 195
 196     /*
 197      *  Interface to the low level console driver
 198      */
 199
 200 int fm2fb_init(void);
 201 static int fm2fbcon_switch(int con, struct fb_info *info);
 202 static int fm2fbcon_updatevar(int con, struct fb_info *info);
 203 static void fm2fbcon_blank(int blank, struct fb_info *info);
 204
 205
 206     /*
 207      *  Internal routines
 208      */
 209
 210 static int fm2fb_getcolreg(u_int regno, u_int *red, u_int *green, u_int *blue,
 211                            u_int *transp, struct fb_info *info);
 212 static int fm2fb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
 213                            u_int transp, struct fb_info *info);
 214 static void do_install_cmap(int con, struct fb_info *info);
 215
 216
 217 static struct fb_ops fm2fb_ops = {
 218         owner:          THIS_MODULE,
 219         fb_get_fix:     fm2fb_get_fix,
 220         fb_get_var:     fm2fb_get_var,
 221         fb_set_var:     fm2fb_set_var,
 222         fb_get_cmap:    fm2fb_get_cmap,
 223         fb_set_cmap:    fm2fb_set_cmap,
 224 };
 225
 226     /*
 227      *  Get the Fixed Part of the Display
 228      */
 229
 230 static int fm2fb_get_fix(struct fb_fix_screeninfo *fix, int con,
 231                          struct fb_info *info)
 232 {
 233     memcpy(fix, &fb_fix, sizeof(fb_fix));
 234     return 0;
 235 }
 236
 237
 238     /*
 239      *  Get the User Defined Part of the Display
 240      */
 241
 242 static int fm2fb_get_var(struct fb_var_screeninfo *var, int con,
 243                          struct fb_info *info)
 244 {
 245     memcpy(var, &fb_var, sizeof(fb_var));
 246     return 0;
 247 }
 248
 249
 250     /*
 251      *  Set the User Defined Part of the Display
 252      */
 253
 254 static int fm2fb_set_var(struct fb_var_screeninfo *var, int con,
 255                          struct fb_info *info)
 256 {
 257     struct display *display;
 258     int oldbpp = -1, err;
 259
 260     if (con >= 0)
 261         display = &fb_display[con];
 262     else
 263         display = &disp;        /* used during initialization */
 264
 265     if (var->xres > fb_var.xres || var->yres > fb_var.yres ||
 266         var->xres_virtual > fb_var.xres_virtual ||
 267         var->yres_virtual > fb_var.yres_virtual ||
 268         var->bits_per_pixel > fb_var.bits_per_pixel ||
 269         var->nonstd ||
 270         (var->vmode & FB_VMODE_MASK) != FB_VMODE_NONINTERLACED)
 271         return -EINVAL;
 272     memcpy(var, &fb_var, sizeof(fb_var));
 273
 274     if ((var->activate & FB_ACTIVATE_MASK) == FB_ACTIVATE_NOW) {
 275         oldbpp = display->var.bits_per_pixel;
 276         display->var = *var;
 277     }
 278     if (oldbpp != var->bits_per_pixel) {
 279         if ((err = fb_alloc_cmap(&display->cmap, 0, 0)))
 280             return err;
 281         do_install_cmap(con, info);
 282     }
 283     return 0;
 284 }
 285
 286
 287     /*
 288      *  Get the Colormap
 289      */
 290
 291 static int fm2fb_get_cmap(struct fb_cmap *cmap, int kspc, int con,
 292                           struct fb_info *info)
 293 {
 294     if (con == currcon) /* current console? */
 295         return fb_get_cmap(cmap, kspc, fm2fb_getcolreg, info);
 296     else if (fb_display[con].cmap.len) /* non default colormap? */
 297         fb_copy_cmap(&fb_display[con].cmap, cmap, kspc ? 0 : 2);
 298     else
 299         fb_copy_cmap(fb_default_cmap(256), cmap, kspc ? 0 : 2);
 300     return 0;
 301 }
 302
 303     /*
 304      *  Set the Colormap
 305      */
 306
 307 static int fm2fb_set_cmap(struct fb_cmap *cmap, int kspc, int con,
 308                           struct fb_info *info)
 309 {
 310     int err;
 311
 312     if (!fb_display[con].cmap.len) {    /* no colormap allocated? */
 313         if ((err = fb_alloc_cmap(&fb_display[con].cmap, 256, 0)))
 314             return err;
 315     }
 316     if (con == currcon) {               /* current console? */
 317         err = fb_set_cmap(cmap, kspc, fm2fb_setcolreg, info);
 318         return err;
 319     } else
 320         fb_copy_cmap(cmap, &fb_display[con].cmap, kspc ? 0 : 1);
 321     return 0;
 322 }
 323
 324
 325     /*
 326      *  Initialisation
 327      */
 328
 329 int __init fm2fb_init(void)
 330 {
 331     int is_fm;
 332     struct zorro_dev *z = NULL;
 333     unsigned long *ptr;
 334     int x, y;
 335
 336     while ((z = zorro_find_device(ZORRO_WILDCARD, z))) {
 337         if (z->id == ZORRO_PROD_BSC_FRAMEMASTER_II)
 338             is_fm = 1;
 339         else if (z->id == ZORRO_PROD_HELFRICH_RAINBOW_II)
 340             is_fm = 0;
 341         else
 342             continue;
 343         if (!request_mem_region(z->resource.start, FRAMEMASTER_SIZE, "fm2fb"))
 344             continue;
 345
 346         /* assigning memory to kernel space */
 347         fm2fb_mem_phys = z->resource.start;
 348         fm2fb_mem  = ioremap(fm2fb_mem_phys, FRAMEMASTER_SIZE);
 349         fm2fb_reg_phys = fm2fb_mem_phys+FRAMEMASTER_REG;
 350         fm2fb_reg  = (unsigned char *)(fm2fb_mem+FRAMEMASTER_REG);
 351
 352         /* make EBU color bars on display */
 353         ptr = (unsigned long *)fm2fb_mem;
 354         for (y = 0; y < 576; y++) {
 355             for (x = 0; x < 96; x++) *ptr++ = 0xffffff; /* white */
 356             for (x = 0; x < 96; x++) *ptr++ = 0xffff00; /* yellow */
 357             for (x = 0; x < 96; x++) *ptr++ = 0x00ffff; /* cyan */
 358             for (x = 0; x < 96; x++) *ptr++ = 0x00ff00; /* green */
 359             for (x = 0; x < 96; x++) *ptr++ = 0xff00ff; /* magenta */
 360             for (x = 0; x < 96; x++) *ptr++ = 0xff0000; /* red */
 361             for (x = 0; x < 96; x++) *ptr++ = 0x0000ff; /* blue */
 362             for (x = 0; x < 96; x++) *ptr++ = 0x000000; /* black */
 363         }
 364         fm2fbcon_blank(0, NULL);
 365
 366         if (fm2fb_mode == -1)
 367             fm2fb_mode = FM2FB_MODE_PAL;
 368
 369         fb_var = fb_var_modes[fm2fb_mode];
 370
 371         strcpy(fb_fix.id, is_fm ? "FrameMaster II" : "Rainbow II");
 372         fb_fix.smem_start = fm2fb_mem_phys;
 373         fb_fix.smem_len = FRAMEMASTER_REG;
 374         fb_fix.type = FB_TYPE_PACKED_PIXELS;
 375         fb_fix.type_aux = 0;
 376         fb_fix.visual = FB_VISUAL_TRUECOLOR;
 377         fb_fix.line_length = 768<<2;
 378         fb_fix.mmio_start = fm2fb_reg_phys;
 379         fb_fix.mmio_len = 8;
 380         fb_fix.accel = FB_ACCEL_NONE;
 381
 382         disp.var = fb_var;
 383         disp.cmap.start = 0;
 384         disp.cmap.len = 0;
 385         disp.cmap.red = disp.cmap.green = disp.cmap.blue = disp.cmap.transp = NULL;
 386         disp.screen_base = (char *)fm2fb_mem;
 387         disp.visual = fb_fix.visual;
 388         disp.type = fb_fix.type;
 389         disp.type_aux = fb_fix.type_aux;
 390         disp.ypanstep = 0;
 391         disp.ywrapstep = 0;
 392         disp.line_length = fb_fix.line_length;
 393         disp.can_soft_blank = 1;
 394         disp.inverse = 0;
 395     #ifdef FBCON_HAS_CFB32
 396         disp.dispsw = &fbcon_cfb32;
 397         disp.dispsw_data = &fbcon_cfb32_cmap;
 398     #else
 399         disp.dispsw = &fbcon_dummy;
 400     #endif
 401         disp.scrollmode = SCROLL_YREDRAW;
 402
 403         strcpy(fb_info.modename, fb_fix.id);
 404         fb_info.node = -1;
 405         fb_info.fbops = &fm2fb_ops;
 406         fb_info.disp = &disp;
 407         fb_info.fontname[0] = '\0';
 408         fb_info.changevar = NULL;
 409         fb_info.switch_con = &fm2fbcon_switch;
 410         fb_info.updatevar = &fm2fbcon_updatevar;
 411         fb_info.blank = &fm2fbcon_blank;
 412         fb_info.flags = FBINFO_FLAG_DEFAULT;
 413
 414         fm2fb_set_var(&fb_var, -1, &fb_info);
 415
 416         if (register_framebuffer(&fb_info) < 0)
 417             return -EINVAL;
 418
 419         printk("fb%d: %s frame buffer device\n", GET_FB_IDX(fb_info.node),
 420                fb_fix.id);
 421         return 0;
 422     }
 423     return -ENXIO;
 424 }
 425
 426 int __init fm2fb_setup(char *options)
 427 {
 428     char *this_opt;
 429
 430     if (!options || !*options)
 431         return 0;
 432
 433     while ((this_opt = strsep(&options, ",")) != NULL) {
 434         if (!strncmp(this_opt, "pal", 3))
 435             fm2fb_mode = FM2FB_MODE_PAL;
 436         else if (!strncmp(this_opt, "ntsc", 4))
 437             fm2fb_mode = FM2FB_MODE_NTSC;
 438     }
 439     return 0;
 440 }
 441
 442
 443 static int fm2fbcon_switch(int con, struct fb_info *info)
 444 {
 445     /* Do we have to save the colormap? */
 446     if (fb_display[currcon].cmap.len)
 447         fb_get_cmap(&fb_display[currcon].cmap, 1, fm2fb_getcolreg, info);
 448
 449     currcon = con;
 450     /* Install new colormap */
 451     do_install_cmap(con, info);
 452     return 0;
 453 }
 454
 455     /*
 456      *  Update the `var' structure (called by fbcon.c)
 457      */
 458
 459 static int fm2fbcon_updatevar(int con, struct fb_info *info)
 460 {
 461     /* Nothing */
 462     return 0;
 463 }
 464
 465     /*
 466      *  Blank the display.
 467      */
 468
 469 static void fm2fbcon_blank(int blank, struct fb_info *info)
 470 {
 471     unsigned char t = FRAMEMASTER_ROM;
 472
 473     if (!blank)
 474         t |= FRAMEMASTER_ENABLE | FRAMEMASTER_NOLACE;
 475     fm2fb_reg[0] = t;
 476 }
 477
 478     /*
 479      *  Read a single color register and split it into
 480      *  colors/transparent. Return != 0 for invalid regno.
 481      */
 482
 483 static int fm2fb_getcolreg(u_int regno, u_int *red, u_int *green, u_int *blue,
 484                          u_int *transp, struct fb_info *info)
 485 {
 486     if (regno > 15)
 487         return 1;
 488     *red = (palette[regno].red<<8) | palette[regno].red;
 489     *green = (palette[regno].green<<8) | palette[regno].green;
 490     *blue = (palette[regno].blue<<8) | palette[regno].blue;
 491     *transp = 0;
 492     return 0;
 493 }
 494
 495
 496     /*
 497      *  Set a single color register. The values supplied are already
 498      *  rounded down to the hardware's capabilities (according to the
 499      *  entries in the var structure). Return != 0 for invalid regno.
 500      */
 501
 502 static int fm2fb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
 503                          u_int transp, struct fb_info *info)
 504 {
 505     if (regno > 15)
 506         return 1;
 507     red >>= 8;
 508     green >>= 8;
 509     blue >>= 8;
 510     palette[regno].red = red;
 511     palette[regno].green = green;
 512     palette[regno].blue = blue;
 513
 514 #ifdef FBCON_HAS_CFB32
 515     fbcon_cfb32_cmap[regno] = (red << 16) | (green << 8) | blue;
 516 #endif
 517     return 0;
 518 }
 519
 520
 521 static void do_install_cmap(int con, struct fb_info *info)
 522 {
 523     if (con != currcon)
 524         return;
 525     if (fb_display[con].cmap.len)
 526         fb_set_cmap(&fb_display[con].cmap, 1, fm2fb_setcolreg, info);
 527     else
 528         fb_set_cmap(fb_default_cmap(256), 1, fm2fb_setcolreg, info);
 529 }
 530
 531 MODULE_LICENSE("GPL");