2 * linux/drivers/video/atafb.c -- Atari builtin chipset frame buffer device
4 * Copyright (C) 1994 Martin Schaller & Roman Hodek
6 * This file is subject to the terms and conditions of the GNU General Public
7 * License. See the file COPYING in the main directory of this archive
11 * - 03 Jan 95: Original version by Martin Schaller: The TT driver and
12 * all the device independent stuff
13 * - 09 Jan 95: Roman: I've added the hardware abstraction (hw_switch)
14 * and wrote the Falcon, ST(E), and External drivers
15 * based on the original TT driver.
16 * - 07 May 95: Martin: Added colormap operations for the external driver
17 * - 21 May 95: Martin: Added support for overscan
18 * Andreas: some bug fixes for this
19 * - Jul 95: Guenther Kelleter <guenther@pool.informatik.rwth-aachen.de>:
20 * Programmable Falcon video modes
21 * (thanks to Christian Cartus for documentation
22 * of VIDEL registers).
23 * - 27 Dec 95: Guenther: Implemented user definable video modes "user[0-7]"
24 * on minor 24...31. "user0" may be set on commandline by
25 * "R<x>;<y>;<depth>". (Makes sense only on Falcon)
26 * Video mode switch on Falcon now done at next VBL interrupt
27 * to avoid the annoying right shift of the screen.
28 * - 23 Sep 97: Juergen: added xres_virtual for cards like ProMST
29 * The external-part is legacy, therefore hardware-specific
30 * functions like panning/hardwarescrolling/blanking isn't
32 * - 29 Sep 97: Juergen: added Romans suggestion for pan_display
33 * (var->xoffset was changed even if no set_screen_base avail.)
34 * - 05 Oct 97: Juergen: extfb (PACKED_PIXEL) is FB_PSEUDOCOLOR 'cause
35 * we know how to set the colors
36 * ext_*palette: read from ext_colors (former MV300_colors)
37 * write to ext_colors and RAMDAC
40 * - For the Falcon it is not possible to set random video modes on
41 * SM124 and SC/TV, only the bootup resolution is supported.
50 #include <linux/module.h>
51 #include <linux/kernel.h>
52 #include <linux/errno.h>
53 #include <linux/string.h>
55 #include <linux/slab.h>
56 #include <linux/delay.h>
57 #include <linux/init.h>
58 #include <linux/interrupt.h>
60 #include <asm/setup.h>
61 #include <linux/uaccess.h>
62 #include <asm/pgtable.h>
66 #include <asm/atarihw.h>
67 #include <asm/atariints.h>
68 #include <asm/atari_stram.h>
71 #include <asm/atarikb.h>
76 #define SWITCH_ACIA 0x01 /* modes for switch on OverScan */
77 #define SWITCH_SND6 0x40
78 #define SWITCH_SND7 0x80
79 #define SWITCH_NONE 0x00
82 #define up(x, r) (((x) + (r) - 1) & ~((r)-1))
85 * Interface to the world
88 static int atafb_check_var(struct fb_var_screeninfo *var, struct fb_info *info);
89 static int atafb_set_par(struct fb_info *info);
90 static int atafb_setcolreg(unsigned int regno, unsigned int red, unsigned int green,
91 unsigned int blue, unsigned int transp,
92 struct fb_info *info);
93 static int atafb_blank(int blank, struct fb_info *info);
94 static int atafb_pan_display(struct fb_var_screeninfo *var,
95 struct fb_info *info);
96 static void atafb_fillrect(struct fb_info *info,
97 const struct fb_fillrect *rect);
98 static void atafb_copyarea(struct fb_info *info,
99 const struct fb_copyarea *region);
100 static void atafb_imageblit(struct fb_info *info, const struct fb_image *image);
101 static int atafb_ioctl(struct fb_info *info, unsigned int cmd,
105 static int default_par; /* default resolution (0=none) */
107 static unsigned long default_mem_req;
109 static int hwscroll = -1;
111 static int use_hwscroll = 1;
113 static int sttt_xres = 640, st_yres = 400, tt_yres = 480;
114 static int sttt_xres_virtual = 640, sttt_yres_virtual = 400;
115 static int ovsc_offset, ovsc_addlen;
118 * Hardware parameters for current mode
121 static struct atafb_par {
125 #if defined ATAFB_TT || defined ATAFB_STE
134 /* Here are fields for storing a video mode, as direct
135 * parameters for the hardware.
145 short hht, hbb, hbe, hdb, hde, hss;
146 short vft, vbb, vbe, vdb, vde, vss;
147 /* auxiliary information */
151 u32 pseudo_palette[16];
154 /* Nothing needed for external mode */
158 /* Don't calculate an own resolution, and thus don't change the one found when
159 * booting (currently used for the Falcon to keep settings for internal video
160 * hardware extensions (e.g. ScreenBlaster) */
161 static int DontCalcRes = 0;
164 #define HHT hw.falcon.hht
165 #define HBB hw.falcon.hbb
166 #define HBE hw.falcon.hbe
167 #define HDB hw.falcon.hdb
168 #define HDE hw.falcon.hde
169 #define HSS hw.falcon.hss
170 #define VFT hw.falcon.vft
171 #define VBB hw.falcon.vbb
172 #define VBE hw.falcon.vbe
173 #define VDB hw.falcon.vdb
174 #define VDE hw.falcon.vde
175 #define VSS hw.falcon.vss
176 #define VCO_CLOCK25 0x04
177 #define VCO_CSYPOS 0x10
178 #define VCO_VSYPOS 0x20
179 #define VCO_HSYPOS 0x40
180 #define VCO_SHORTOFFS 0x100
181 #define VMO_DOUBLE 0x01
182 #define VMO_INTER 0x02
183 #define VMO_PREMASK 0x0c
186 static struct fb_info fb_info = {
189 .visual = FB_VISUAL_PSEUDOCOLOR,
190 .accel = FB_ACCEL_NONE,
194 static void *screen_base; /* base address of screen */
195 static void *real_screen_base; /* (only for Overscan) */
197 static int screen_len;
199 static int current_par_valid;
201 static int mono_moni;
206 /* external video handling */
207 static unsigned int external_xres;
208 static unsigned int external_xres_virtual;
209 static unsigned int external_yres;
212 * not needed - atafb will never support panning/hardwarescroll with external
213 * static unsigned int external_yres_virtual;
215 static unsigned int external_depth;
216 static int external_pmode;
217 static void *external_addr;
218 static unsigned long external_len;
219 static unsigned long external_vgaiobase;
220 static unsigned int external_bitspercol = 6;
223 * JOE <joe@amber.dinoco.de>:
224 * added card type for external driver, is only needed for
227 enum cardtype { IS_VGA, IS_MV300 };
228 static enum cardtype external_card_type = IS_VGA;
231 * The MV300 mixes the color registers. So we need an array of munged
232 * indices in order to access the correct reg.
234 static int MV300_reg_1bit[2] = {
237 static int MV300_reg_4bit[16] = {
238 0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15
240 static int MV300_reg_8bit[256] = {
241 0, 128, 64, 192, 32, 160, 96, 224, 16, 144, 80, 208, 48, 176, 112, 240,
242 8, 136, 72, 200, 40, 168, 104, 232, 24, 152, 88, 216, 56, 184, 120, 248,
243 4, 132, 68, 196, 36, 164, 100, 228, 20, 148, 84, 212, 52, 180, 116, 244,
244 12, 140, 76, 204, 44, 172, 108, 236, 28, 156, 92, 220, 60, 188, 124, 252,
245 2, 130, 66, 194, 34, 162, 98, 226, 18, 146, 82, 210, 50, 178, 114, 242,
246 10, 138, 74, 202, 42, 170, 106, 234, 26, 154, 90, 218, 58, 186, 122, 250,
247 6, 134, 70, 198, 38, 166, 102, 230, 22, 150, 86, 214, 54, 182, 118, 246,
248 14, 142, 78, 206, 46, 174, 110, 238, 30, 158, 94, 222, 62, 190, 126, 254,
249 1, 129, 65, 193, 33, 161, 97, 225, 17, 145, 81, 209, 49, 177, 113, 241,
250 9, 137, 73, 201, 41, 169, 105, 233, 25, 153, 89, 217, 57, 185, 121, 249,
251 5, 133, 69, 197, 37, 165, 101, 229, 21, 149, 85, 213, 53, 181, 117, 245,
252 13, 141, 77, 205, 45, 173, 109, 237, 29, 157, 93, 221, 61, 189, 125, 253,
253 3, 131, 67, 195, 35, 163, 99, 227, 19, 147, 83, 211, 51, 179, 115, 243,
254 11, 139, 75, 203, 43, 171, 107, 235, 27, 155, 91, 219, 59, 187, 123, 251,
255 7, 135, 71, 199, 39, 167, 103, 231, 23, 151, 87, 215, 55, 183, 119, 247,
256 15, 143, 79, 207, 47, 175, 111, 239, 31, 159, 95, 223, 63, 191, 127, 255
259 static int *MV300_reg = MV300_reg_8bit;
260 #endif /* ATAFB_EXT */
265 extern int fontheight_8x8;
266 extern int fontwidth_8x8;
267 extern unsigned char fontdata_8x8[];
269 extern int fontheight_8x16;
270 extern int fontwidth_8x16;
271 extern unsigned char fontdata_8x16[];
275 * * open/release and usage marking
276 * struct module *owner;
277 * int (*fb_open)(struct fb_info *info, int user);
278 * int (*fb_release)(struct fb_info *info, int user);
280 * * For framebuffers with strange non linear layouts or that do not
281 * * work with normal memory mapped access
282 * ssize_t (*fb_read)(struct file *file, char __user *buf, size_t count, loff_t *ppos);
283 * ssize_t (*fb_write)(struct file *file, const char __user *buf, size_t count, loff_t *ppos);
285 * * checks var and eventually tweaks it to something supported,
286 * * DOES NOT MODIFY PAR *
287 * int (*fb_check_var)(struct fb_var_screeninfo *var, struct fb_info *info);
289 * * set the video mode according to info->var *
290 * int (*fb_set_par)(struct fb_info *info);
292 * * set color register *
293 * int (*fb_setcolreg)(unsigned int regno, unsigned int red, unsigned int green,
294 * unsigned int blue, unsigned int transp, struct fb_info *info);
296 * * set color registers in batch *
297 * int (*fb_setcmap)(struct fb_cmap *cmap, struct fb_info *info);
300 * int (*fb_blank)(int blank, struct fb_info *info);
303 * int (*fb_pan_display)(struct fb_var_screeninfo *var, struct fb_info *info);
305 * *** The meat of the drawing engine ***
306 * * Draws a rectangle *
307 * void (*fb_fillrect) (struct fb_info *info, const struct fb_fillrect *rect);
308 * * Copy data from area to another *
309 * void (*fb_copyarea) (struct fb_info *info, const struct fb_copyarea *region);
310 * * Draws a image to the display *
311 * void (*fb_imageblit) (struct fb_info *info, const struct fb_image *image);
314 * int (*fb_cursor) (struct fb_info *info, struct fb_cursor *cursor);
316 * * Rotates the display *
317 * void (*fb_rotate)(struct fb_info *info, int angle);
319 * * wait for blit idle, optional *
320 * int (*fb_sync)(struct fb_info *info);
322 * * perform fb specific ioctl (optional) *
323 * int (*fb_ioctl)(struct fb_info *info, unsigned int cmd,
324 * unsigned long arg);
326 * * Handle 32bit compat ioctl (optional) *
327 * int (*fb_compat_ioctl)(struct fb_info *info, unsigned int cmd,
328 * unsigned long arg);
330 * * perform fb specific mmap *
331 * int (*fb_mmap)(struct fb_info *info, struct vm_area_struct *vma);
333 * * save current hardware state *
334 * void (*fb_save_state)(struct fb_info *info);
336 * * restore saved state *
337 * void (*fb_restore_state)(struct fb_info *info);
342 /* ++roman: This structure abstracts from the underlying hardware (ST(e),
345 * int (*detect)(void)
346 * This function should detect the current video mode settings and
347 * store them in atafb_predefined[0] for later reference by the
348 * user. Return the index+1 of an equivalent predefined mode or 0
349 * if there is no such.
351 * int (*encode_fix)(struct fb_fix_screeninfo *fix,
352 * struct atafb_par *par)
353 * This function should fill in the 'fix' structure based on the
354 * values in the 'par' structure.
355 * !!! Obsolete, perhaps !!!
357 * int (*decode_var)(struct fb_var_screeninfo *var,
358 * struct atafb_par *par)
359 * Get the video params out of 'var'. If a value doesn't fit, round
360 * it up, if it's too big, return EINVAL.
361 * Round up in the following order: bits_per_pixel, xres, yres,
362 * xres_virtual, yres_virtual, xoffset, yoffset, grayscale, bitfields,
363 * horizontal timing, vertical timing.
365 * int (*encode_var)(struct fb_var_screeninfo *var,
366 * struct atafb_par *par);
367 * Fill the 'var' structure based on the values in 'par' and maybe
368 * other values read out of the hardware.
370 * void (*get_par)(struct atafb_par *par)
371 * Fill the hardware's 'par' structure.
372 * !!! Used only by detect() !!!
374 * void (*set_par)(struct atafb_par *par)
375 * Set the hardware according to 'par'.
377 * void (*set_screen_base)(void *s_base)
378 * Set the base address of the displayed frame buffer. Only called
379 * if yres_virtual > yres or xres_virtual > xres.
381 * int (*blank)(int blank_mode)
382 * Blank the screen if blank_mode != 0, else unblank. If blank == NULL then
383 * the caller blanks by setting the CLUT to all black. Return 0 if blanking
384 * succeeded, !=0 if un-/blanking failed due to e.g. a video mode which
385 * doesn't support it. Implements VESA suspend and powerdown modes on
386 * hardware that supports disabling hsync/vsync:
387 * blank_mode == 2: suspend vsync, 3:suspend hsync, 4: powerdown.
390 static struct fb_hwswitch {
392 int (*encode_fix)(struct fb_fix_screeninfo *fix,
393 struct atafb_par *par);
394 int (*decode_var)(struct fb_var_screeninfo *var,
395 struct atafb_par *par);
396 int (*encode_var)(struct fb_var_screeninfo *var,
397 struct atafb_par *par);
398 void (*get_par)(struct atafb_par *par);
399 void (*set_par)(struct atafb_par *par);
400 void (*set_screen_base)(void *s_base);
401 int (*blank)(int blank_mode);
402 int (*pan_display)(struct fb_var_screeninfo *var,
403 struct fb_info *info);
406 static char *autodetect_names[] = { "autodetect", NULL };
407 static char *stlow_names[] = { "stlow", NULL };
408 static char *stmid_names[] = { "stmid", "default5", NULL };
409 static char *sthigh_names[] = { "sthigh", "default4", NULL };
410 static char *ttlow_names[] = { "ttlow", NULL };
411 static char *ttmid_names[] = { "ttmid", "default1", NULL };
412 static char *tthigh_names[] = { "tthigh", "default2", NULL };
413 static char *vga2_names[] = { "vga2", NULL };
414 static char *vga4_names[] = { "vga4", NULL };
415 static char *vga16_names[] = { "vga16", "default3", NULL };
416 static char *vga256_names[] = { "vga256", NULL };
417 static char *falh2_names[] = { "falh2", NULL };
418 static char *falh16_names[] = { "falh16", NULL };
420 static char **fb_var_names[] = {
437 static struct fb_var_screeninfo atafb_predefined[] = {
439 * yres_virtual == 0 means use hw-scrolling if possible, else yres
442 0, 0, 0, 0, 0, 0, 0, 0, /* xres-grayscale */
443 {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, /* red green blue tran*/
444 0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0 },
446 320, 200, 320, 0, 0, 0, 4, 0,
447 {0, 4, 0}, {0, 4, 0}, {0, 4, 0}, {0, 0, 0},
448 0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0 },
450 640, 200, 640, 0, 0, 0, 2, 0,
451 {0, 4, 0}, {0, 4, 0}, {0, 4, 0}, {0, 0, 0},
452 0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0 },
454 640, 400, 640, 0, 0, 0, 1, 0,
455 {0, 4, 0}, {0, 4, 0}, {0, 4, 0}, {0, 0, 0},
456 0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0 },
458 320, 480, 320, 0, 0, 0, 8, 0,
459 {0, 4, 0}, {0, 4, 0}, {0, 4, 0}, {0, 0, 0},
460 0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0 },
462 640, 480, 640, 0, 0, 0, 4, 0,
463 {0, 4, 0}, {0, 4, 0}, {0, 4, 0}, {0, 0, 0},
464 0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0 },
466 1280, 960, 1280, 0, 0, 0, 1, 0,
467 {0, 4, 0}, {0, 4, 0}, {0, 4, 0}, {0, 0, 0},
468 0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0 },
470 640, 480, 640, 0, 0, 0, 1, 0,
471 {0, 6, 0}, {0, 6, 0}, {0, 6, 0}, {0, 0, 0},
472 0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0 },
474 640, 480, 640, 0, 0, 0, 2, 0,
475 {0, 4, 0}, {0, 4, 0}, {0, 4, 0}, {0, 0, 0},
476 0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0 },
478 640, 480, 640, 0, 0, 0, 4, 0,
479 {0, 6, 0}, {0, 6, 0}, {0, 6, 0}, {0, 0, 0},
480 0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0 },
482 640, 480, 640, 0, 0, 0, 8, 0,
483 {0, 6, 0}, {0, 6, 0}, {0, 6, 0}, {0, 0, 0},
484 0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0 },
486 896, 608, 896, 0, 0, 0, 1, 0,
487 {0, 6, 0}, {0, 6, 0}, {0, 6, 0}, {0, 0, 0},
488 0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0 },
490 896, 608, 896, 0, 0, 0, 4, 0,
491 {0, 6, 0}, {0, 6, 0}, {0, 6, 0}, {0, 0, 0},
492 0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0 },
495 static int num_atafb_predefined = ARRAY_SIZE(atafb_predefined);
497 static struct fb_videomode atafb_modedb[] __initdata = {
501 * If you change these, make sure to update DEFMODE_* as well!
509 /* 320x200, 15 kHz, 60 Hz (ST low) */
510 "st-low", 60, 320, 200, 32000, 32, 16, 31, 14, 96, 4,
511 0, FB_VMODE_NONINTERLACED | FB_VMODE_YWRAP
513 /* 640x200, 15 kHz, 60 Hz (ST medium) */
514 "st-mid", 60, 640, 200, 32000, 32, 16, 31, 14, 96, 4,
515 0, FB_VMODE_NONINTERLACED | FB_VMODE_YWRAP
517 /* 640x400, 30.25 kHz, 63.5 Hz (ST high) */
518 "st-high", 63, 640, 400, 32000, 128, 0, 40, 14, 128, 4,
519 0, FB_VMODE_NONINTERLACED | FB_VMODE_YWRAP
521 /* 320x480, 15 kHz, 60 Hz (TT low) */
522 "tt-low", 60, 320, 480, 31041, 120, 100, 8, 16, 140, 30,
523 0, FB_VMODE_NONINTERLACED | FB_VMODE_YWRAP
525 /* 640x480, 29 kHz, 57 Hz (TT medium) */
526 "tt-mid", 60, 640, 480, 31041, 120, 100, 8, 16, 140, 30,
527 0, FB_VMODE_NONINTERLACED | FB_VMODE_YWRAP
529 /* 1280x960, 29 kHz, 60 Hz (TT high) */
530 "tt-high", 57, 640, 960, 31041, 120, 100, 8, 16, 140, 30,
531 0, FB_VMODE_NONINTERLACED | FB_VMODE_YWRAP
539 /* 640x480, 31 kHz, 60 Hz (VGA) */
540 "vga", 63.5, 640, 480, 32000, 18, 42, 31, 11, 96, 3,
541 0, FB_VMODE_NONINTERLACED | FB_VMODE_YWRAP
543 /* 640x400, 31 kHz, 70 Hz (VGA) */
544 "vga70", 70, 640, 400, 32000, 18, 42, 31, 11, 96, 3,
545 FB_SYNC_VERT_HIGH_ACT | FB_SYNC_COMP_HIGH_ACT, FB_VMODE_NONINTERLACED | FB_VMODE_YWRAP
549 * Falcon HiRes Video Modes
553 /* 896x608, 31 kHz, 60 Hz (Falcon High) */
554 "falh", 60, 896, 608, 32000, 18, 42, 31, 1, 96,3,
555 0, FB_VMODE_NONINTERLACED | FB_VMODE_YWRAP
559 #define NUM_TOTAL_MODES ARRAY_SIZE(atafb_modedb)
561 static char *mode_option __initdata = NULL;
565 #define DEFMODE_TT 5 /* "tt-high" for TT */
566 #define DEFMODE_F30 7 /* "vga70" for Falcon */
567 #define DEFMODE_STE 2 /* "st-high" for ST/E */
568 #define DEFMODE_EXT 6 /* "vga" for external */
571 static int get_video_mode(char *vname)
577 name_list = fb_var_names;
578 for (i = 0; i < num_atafb_predefined; i++) {
583 if (!strcmp(vname, *name))
593 /* ------------------- TT specific functions ---------------------- */
597 static int tt_encode_fix(struct fb_fix_screeninfo *fix, struct atafb_par *par)
601 strcpy(fix->id, "Atari Builtin");
602 fix->smem_start = (unsigned long)real_screen_base;
603 fix->smem_len = screen_len;
604 fix->type = FB_TYPE_INTERLEAVED_PLANES;
606 fix->visual = FB_VISUAL_PSEUDOCOLOR;
607 mode = par->hw.tt.mode & TT_SHIFTER_MODEMASK;
608 if (mode == TT_SHIFTER_TTHIGH || mode == TT_SHIFTER_STHIGH) {
609 fix->type = FB_TYPE_PACKED_PIXELS;
611 if (mode == TT_SHIFTER_TTHIGH)
612 fix->visual = FB_VISUAL_MONO01;
617 fix->line_length = par->next_line;
618 fix->accel = FB_ACCEL_ATARIBLITT;
622 static int tt_decode_var(struct fb_var_screeninfo *var, struct atafb_par *par)
624 int xres = var->xres;
625 int yres = var->yres;
626 int bpp = var->bits_per_pixel;
628 int yres_virtual = var->yres_virtual;
631 if (bpp > 1 || xres > sttt_xres * 2 || yres > tt_yres * 2)
633 par->hw.tt.mode = TT_SHIFTER_TTHIGH;
634 xres = sttt_xres * 2;
638 if (bpp > 8 || xres > sttt_xres || yres > tt_yres)
641 if (xres > sttt_xres / 2 || yres > tt_yres)
643 par->hw.tt.mode = TT_SHIFTER_TTLOW;
644 xres = sttt_xres / 2;
647 } else if (bpp > 2) {
648 if (xres > sttt_xres || yres > tt_yres)
650 if (xres > sttt_xres / 2 || yres > st_yres / 2) {
651 par->hw.tt.mode = TT_SHIFTER_TTMID;
656 par->hw.tt.mode = TT_SHIFTER_STLOW;
657 xres = sttt_xres / 2;
661 } else if (bpp > 1) {
662 if (xres > sttt_xres || yres > st_yres / 2)
664 par->hw.tt.mode = TT_SHIFTER_STMID;
668 } else if (var->xres > sttt_xres || var->yres > st_yres) {
671 par->hw.tt.mode = TT_SHIFTER_STHIGH;
677 if (yres_virtual <= 0)
679 else if (yres_virtual < yres)
681 if (var->sync & FB_SYNC_EXT)
685 linelen = xres * bpp / 8;
686 if (yres_virtual * linelen > screen_len && screen_len)
688 if (yres * linelen > screen_len && screen_len)
690 if (var->yoffset + yres > yres_virtual && yres_virtual)
692 par->yres_virtual = yres_virtual;
693 par->screen_base = screen_base + var->yoffset * linelen;
694 par->next_line = linelen;
698 static int tt_encode_var(struct fb_var_screeninfo *var, struct atafb_par *par)
701 memset(var, 0, sizeof(struct fb_var_screeninfo));
704 var->red.msb_right = 0;
707 var->pixclock = 31041;
708 var->left_margin = 120; /* these may be incorrect */
709 var->right_margin = 100;
710 var->upper_margin = 8;
711 var->lower_margin = 16;
712 var->hsync_len = 140;
718 if (par->hw.tt.sync & 1)
721 var->sync = FB_SYNC_EXT;
723 switch (par->hw.tt.mode & TT_SHIFTER_MODEMASK) {
724 case TT_SHIFTER_STLOW:
725 var->xres = sttt_xres / 2;
726 var->xres_virtual = sttt_xres_virtual / 2;
727 var->yres = st_yres / 2;
728 var->bits_per_pixel = 4;
730 case TT_SHIFTER_STMID:
731 var->xres = sttt_xres;
732 var->xres_virtual = sttt_xres_virtual;
733 var->yres = st_yres / 2;
734 var->bits_per_pixel = 2;
736 case TT_SHIFTER_STHIGH:
737 var->xres = sttt_xres;
738 var->xres_virtual = sttt_xres_virtual;
740 var->bits_per_pixel = 1;
742 case TT_SHIFTER_TTLOW:
743 var->xres = sttt_xres / 2;
744 var->xres_virtual = sttt_xres_virtual / 2;
746 var->bits_per_pixel = 8;
748 case TT_SHIFTER_TTMID:
749 var->xres = sttt_xres;
750 var->xres_virtual = sttt_xres_virtual;
752 var->bits_per_pixel = 4;
754 case TT_SHIFTER_TTHIGH:
756 var->xres = sttt_xres * 2;
757 var->xres_virtual = sttt_xres_virtual * 2;
758 var->yres = tt_yres * 2;
759 var->bits_per_pixel = 1;
762 var->blue = var->green = var->red;
763 var->transp.offset = 0;
764 var->transp.length = 0;
765 var->transp.msb_right = 0;
766 linelen = var->xres_virtual * var->bits_per_pixel / 8;
768 var->yres_virtual = var->yres;
769 else if (screen_len) {
770 if (par->yres_virtual)
771 var->yres_virtual = par->yres_virtual;
773 /* yres_virtual == 0 means use maximum */
774 var->yres_virtual = screen_len / linelen;
777 var->yres_virtual = 2 * var->yres;
779 var->yres_virtual = var->yres + hwscroll * 16;
783 var->yoffset = (par->screen_base - screen_base) / linelen;
788 var->vmode = FB_VMODE_NONINTERLACED;
792 static void tt_get_par(struct atafb_par *par)
795 par->hw.tt.mode = shifter_tt.tt_shiftmode;
796 par->hw.tt.sync = shifter.syncmode;
797 addr = ((shifter.bas_hi & 0xff) << 16) |
798 ((shifter.bas_md & 0xff) << 8) |
799 ((shifter.bas_lo & 0xff));
800 par->screen_base = phys_to_virt(addr);
803 static void tt_set_par(struct atafb_par *par)
805 shifter_tt.tt_shiftmode = par->hw.tt.mode;
806 shifter.syncmode = par->hw.tt.sync;
807 /* only set screen_base if really necessary */
808 if (current_par.screen_base != par->screen_base)
809 fbhw->set_screen_base(par->screen_base);
812 static int tt_setcolreg(unsigned int regno, unsigned int red,
813 unsigned int green, unsigned int blue,
814 unsigned int transp, struct fb_info *info)
816 if ((shifter_tt.tt_shiftmode & TT_SHIFTER_MODEMASK) == TT_SHIFTER_STHIGH)
820 tt_palette[regno] = (((red >> 12) << 8) | ((green >> 12) << 4) |
822 if ((shifter_tt.tt_shiftmode & TT_SHIFTER_MODEMASK) ==
823 TT_SHIFTER_STHIGH && regno == 254)
828 static int tt_detect(void)
830 struct atafb_par par;
832 /* Determine the connected monitor: The DMA sound must be
833 * disabled before reading the MFP GPIP, because the Sound
834 * Done Signal and the Monochrome Detect are XORed together!
836 * Even on a TT, we should look if there is a DMA sound. It was
837 * announced that the Eagle is TT compatible, but only the PCM is
840 if (ATARIHW_PRESENT(PCM_8BIT)) {
841 tt_dmasnd.ctrl = DMASND_CTRL_OFF;
842 udelay(20); /* wait a while for things to settle down */
844 mono_moni = (st_mfp.par_dt_reg & 0x80) == 0;
847 tt_encode_var(&atafb_predefined[0], &par);
852 #endif /* ATAFB_TT */
854 /* ------------------- Falcon specific functions ---------------------- */
858 static int mon_type; /* Falcon connected monitor */
859 static int f030_bus_width; /* Falcon ram bus width (for vid_control) */
865 static struct pixel_clock {
866 unsigned long f; /* f/[Hz] */
867 unsigned long t; /* t/[ps] (=1/f) */
868 int right, hsync, left; /* standard timing in clock cycles, not pixel */
869 /* hsync initialized in falcon_detect() */
870 int sync_mask; /* or-mask for hw.falcon.sync to set this clock */
871 int control_mask; /* ditto, for hw.falcon.vid_control */
873 25175000, 39721, 18, 0, 42, 0x0, VCO_CLOCK25
875 32000000, 31250, 18, 0, 42, 0x0, 0
877 0, 0, 18, 0, 42, 0x1, 0
880 /* VIDEL-prescale values [mon_type][pixel_length from VCO] */
881 static int vdl_prescale[4][3] = {
882 { 4,2,1 }, { 4,2,1 }, { 4,2,2 }, { 4,2,1 }
885 /* Default hsync timing [mon_type] in picoseconds */
886 static long h_syncs[4] = { 3000000, 4875000, 4000000, 4875000 };
888 static inline int hxx_prescale(struct falcon_hw *hw)
890 return hw->ste_mode ? 16
891 : vdl_prescale[mon_type][hw->vid_mode >> 2 & 0x3];
894 static int falcon_encode_fix(struct fb_fix_screeninfo *fix,
895 struct atafb_par *par)
897 strcpy(fix->id, "Atari Builtin");
898 fix->smem_start = (unsigned long)real_screen_base;
899 fix->smem_len = screen_len;
900 fix->type = FB_TYPE_INTERLEAVED_PLANES;
902 fix->visual = FB_VISUAL_PSEUDOCOLOR;
906 if (par->hw.falcon.mono) {
907 fix->type = FB_TYPE_PACKED_PIXELS;
909 /* no smooth scrolling with longword aligned video mem */
911 } else if (par->hw.falcon.f_shift & 0x100) {
912 fix->type = FB_TYPE_PACKED_PIXELS;
914 /* Is this ok or should it be DIRECTCOLOR? */
915 fix->visual = FB_VISUAL_TRUECOLOR;
918 fix->line_length = par->next_line;
919 fix->accel = FB_ACCEL_ATARIBLITT;
923 static int falcon_decode_var(struct fb_var_screeninfo *var,
924 struct atafb_par *par)
926 int bpp = var->bits_per_pixel;
927 int xres = var->xres;
928 int yres = var->yres;
929 int xres_virtual = var->xres_virtual;
930 int yres_virtual = var->yres_virtual;
931 int left_margin, right_margin, hsync_len;
932 int upper_margin, lower_margin, vsync_len;
934 int interlace = 0, doubleline = 0;
935 struct pixel_clock *pclock;
936 int plen; /* width of pixel in clock cycles */
941 int hdb_off, hde_off, base_off;
942 int gstart, gend1, gend2, align;
945 Get the video params out of 'var'. If a value doesn't fit, round
946 it up, if it's too big, return EINVAL.
947 Round up in the following order: bits_per_pixel, xres, yres,
948 xres_virtual, yres_virtual, xoffset, yoffset, grayscale, bitfields,
949 horizontal timing, vertical timing.
951 There is a maximum of screen resolution determined by pixelclock
952 and minimum frame rate -- (X+hmarg.)*(Y+vmarg.)*vfmin <= pixelclock.
953 In interlace mode this is " * " *vfmin <= pixelclock.
954 Additional constraints: hfreq.
955 Frequency range for multisync monitors is given via command line.
956 For TV and SM124 both frequencies are fixed.
958 X % 16 == 0 to fit 8x?? font (except 1 bitplane modes must use X%32 == 0)
959 Y % 16 == 0 to fit 8x16 font
962 Currently interlace and doubleline mode in var are ignored.
963 On SM124 and TV only the standard resolutions can be used.
966 /* Reject uninitialized mode */
967 if (!xres || !yres || !bpp)
970 if (mon_type == F_MON_SM && bpp != 1)
975 par->hw.falcon.f_shift = 0x400;
976 par->hw.falcon.st_shift = 0x200;
977 } else if (bpp <= 2) {
979 par->hw.falcon.f_shift = 0x000;
980 par->hw.falcon.st_shift = 0x100;
981 } else if (bpp <= 4) {
983 par->hw.falcon.f_shift = 0x000;
984 par->hw.falcon.st_shift = 0x000;
985 } else if (bpp <= 8) {
987 par->hw.falcon.f_shift = 0x010;
988 } else if (bpp <= 16) {
989 bpp = 16; /* packed pixel mode */
990 par->hw.falcon.f_shift = 0x100; /* hicolor, no overlay */
993 par->hw.falcon.bpp = bpp;
995 if (mon_type == F_MON_SM || DontCalcRes) {
996 /* Skip all calculations. VGA/TV/SC1224 only supported. */
997 struct fb_var_screeninfo *myvar = &atafb_predefined[0];
999 if (bpp > myvar->bits_per_pixel ||
1000 var->xres > myvar->xres ||
1001 var->yres > myvar->yres)
1003 fbhw->get_par(par); /* Current par will be new par */
1004 goto set_screen_base; /* Don't forget this */
1007 /* Only some fixed resolutions < 640x400 */
1010 else if (xres <= 640 && bpp != 16)
1014 else if (yres <= 240)
1016 else if (yres <= 400)
1019 /* 2 planes must use STE compatibility mode */
1020 par->hw.falcon.ste_mode = bpp == 2;
1021 par->hw.falcon.mono = bpp == 1;
1023 /* Total and visible scanline length must be a multiple of one longword,
1024 * this and the console fontwidth yields the alignment for xres and
1026 * TODO: this way "odd" fontheights are not supported
1028 * Special case in STE mode: blank and graphic positions don't align,
1029 * avoid trash at right margin
1031 if (par->hw.falcon.ste_mode)
1032 xres = (xres + 63) & ~63;
1034 xres = (xres + 31) & ~31;
1036 xres = (xres + 15) & ~15;
1038 yres = (yres + 15) & ~15;
1040 yres = (yres + 7) & ~7;
1042 if (xres_virtual < xres)
1043 xres_virtual = xres;
1045 xres_virtual = (xres_virtual + 31) & ~31;
1047 xres_virtual = (xres_virtual + 15) & ~15;
1049 if (yres_virtual <= 0)
1051 else if (yres_virtual < yres)
1052 yres_virtual = yres;
1054 /* backward bug-compatibility */
1055 if (var->pixclock > 1)
1058 par->hw.falcon.line_width = bpp * xres / 16;
1059 par->hw.falcon.line_offset = bpp * (xres_virtual - xres) / 16;
1061 /* single or double pixel width */
1062 xstretch = (xres < 640) ? 2 : 1;
1064 #if 0 /* SM124 supports only 640x400, this is rejected above */
1065 if (mon_type == F_MON_SM) {
1066 if (xres != 640 && yres != 400)
1070 /* SM124-mode is special */
1071 par->hw.falcon.ste_mode = 1;
1072 par->hw.falcon.f_shift = 0x000;
1073 par->hw.falcon.st_shift = 0x200;
1074 left_margin = hsync_len = 128 / plen;
1076 /* TODO set all margins */
1079 if (mon_type == F_MON_SC || mon_type == F_MON_TV) {
1080 plen = 2 * xstretch;
1081 if (var->pixclock > f32.t * plen)
1086 if (var->pixclock == 0) {
1087 /* set some minimal margins which center the screen */
1090 hsync_len = pclock->hsync / plen;
1093 vsync_len = interlace ? 3 : 4;
1095 left_margin = var->left_margin;
1096 right_margin = var->right_margin;
1097 hsync_len = var->hsync_len;
1098 upper_margin = var->upper_margin;
1099 lower_margin = var->lower_margin;
1100 vsync_len = var->vsync_len;
1101 if (var->vmode & FB_VMODE_INTERLACED) {
1102 upper_margin = (upper_margin + 1) / 2;
1103 lower_margin = (lower_margin + 1) / 2;
1104 vsync_len = (vsync_len + 1) / 2;
1105 } else if (var->vmode & FB_VMODE_DOUBLE) {
1111 } else { /* F_MON_VGA */
1113 xstretch = 2; /* Double pixel width only for hicolor */
1114 /* Default values are used for vert./hor. timing if no pixelclock given. */
1115 if (var->pixclock == 0) {
1118 /* Choose master pixelclock depending on hor. timing */
1119 plen = 1 * xstretch;
1120 if ((plen * xres + f25.right + f25.hsync + f25.left) *
1121 fb_info.monspecs.hfmin < f25.f)
1123 else if ((plen * xres + f32.right + f32.hsync +
1124 f32.left) * fb_info.monspecs.hfmin < f32.f)
1126 else if ((plen * xres + fext.right + fext.hsync +
1127 fext.left) * fb_info.monspecs.hfmin < fext.f &&
1133 left_margin = pclock->left / plen;
1134 right_margin = pclock->right / plen;
1135 hsync_len = pclock->hsync / plen;
1136 linesize = left_margin + xres + right_margin + hsync_len;
1141 /* Choose largest pixelclock <= wanted clock */
1143 unsigned long pcl = ULONG_MAX;
1145 for (i = 1; i <= 4; i *= 2) {
1146 if (f25.t * i >= var->pixclock &&
1151 if (f32.t * i >= var->pixclock &&
1156 if (fext.t && fext.t * i >= var->pixclock &&
1164 plen = pcl / pclock->t;
1166 left_margin = var->left_margin;
1167 right_margin = var->right_margin;
1168 hsync_len = var->hsync_len;
1169 upper_margin = var->upper_margin;
1170 lower_margin = var->lower_margin;
1171 vsync_len = var->vsync_len;
1172 /* Internal unit is [single lines per (half-)frame] */
1173 if (var->vmode & FB_VMODE_INTERLACED) {
1174 /* # lines in half frame */
1175 /* External unit is [lines per full frame] */
1176 upper_margin = (upper_margin + 1) / 2;
1177 lower_margin = (lower_margin + 1) / 2;
1178 vsync_len = (vsync_len + 1) / 2;
1179 } else if (var->vmode & FB_VMODE_DOUBLE) {
1180 /* External unit is [double lines per frame] */
1186 if (pclock == &fext)
1187 longoffset = 1; /* VIDEL doesn't synchronize on short offset */
1189 /* Is video bus bandwidth (32MB/s) too low for this resolution? */
1190 /* this is definitely wrong if bus clock != 32MHz */
1191 if (pclock->f / plen / 8 * bpp > 32000000L)
1197 /* include sync lengths in right/lower margin for all calculations */
1198 right_margin += hsync_len;
1199 lower_margin += vsync_len;
1201 /* ! In all calculations of margins we use # of lines in half frame
1202 * (which is a full frame in non-interlace mode), so we can switch
1203 * between interlace and non-interlace without messing around
1207 /* Set base_offset 128 and video bus width */
1208 par->hw.falcon.vid_control = mon_type | f030_bus_width;
1210 par->hw.falcon.vid_control |= VCO_SHORTOFFS; /* base_offset 64 */
1211 if (var->sync & FB_SYNC_HOR_HIGH_ACT)
1212 par->hw.falcon.vid_control |= VCO_HSYPOS;
1213 if (var->sync & FB_SYNC_VERT_HIGH_ACT)
1214 par->hw.falcon.vid_control |= VCO_VSYPOS;
1216 par->hw.falcon.vid_control |= pclock->control_mask;
1217 /* External or internal clock */
1218 par->hw.falcon.sync = pclock->sync_mask | 0x2;
1219 /* Pixellength and prescale */
1220 par->hw.falcon.vid_mode = (2 / plen) << 2;
1222 par->hw.falcon.vid_mode |= VMO_DOUBLE;
1224 par->hw.falcon.vid_mode |= VMO_INTER;
1226 /*********************
1227 * Horizontal timing: unit = [master clock cycles]
1228 * unit of hxx-registers: [master clock cycles * prescale]
1229 * Hxx-registers are 9 bit wide
1231 * 1 line = ((hht + 2) * 2 * prescale) clock cycles
1233 * graphic output = hdb & 0x200 ?
1234 * ((hht + 2) * 2 - hdb + hde) * prescale - hdboff + hdeoff:
1235 * (hht + 2 - hdb + hde) * prescale - hdboff + hdeoff
1236 * (this must be a multiple of plen*128/bpp, on VGA pixels
1237 * to the right may be cut off with a bigger right margin)
1239 * start of graphics relative to start of 1st halfline = hdb & 0x200 ?
1240 * (hdb - hht - 2) * prescale + hdboff :
1241 * hdb * prescale + hdboff
1243 * end of graphics relative to start of 1st halfline =
1244 * (hde + hht + 2) * prescale + hdeoff
1245 *********************/
1246 /* Calculate VIDEL registers */
1248 prescale = hxx_prescale(&par->hw.falcon);
1249 base_off = par->hw.falcon.vid_control & VCO_SHORTOFFS ? 64 : 128;
1251 /* Offsets depend on video mode */
1252 /* Offsets are in clock cycles, divide by prescale to
1253 * calculate hd[be]-registers
1255 if (par->hw.falcon.f_shift & 0x100) {
1258 hdb_off = (base_off + 16 * plen) + prescale;
1261 hde_off = ((128 / bpp + 2) * plen);
1262 if (par->hw.falcon.ste_mode)
1263 hdb_off = (64 + base_off + (128 / bpp + 2) * plen) + prescale;
1265 hdb_off = (base_off + (128 / bpp + 18) * plen) + prescale;
1268 gstart = (prescale / 2 + plen * left_margin) / prescale;
1269 /* gend1 is for hde (gend-gstart multiple of align), shifter's xres */
1270 gend1 = gstart + roundup(xres, align) * plen / prescale;
1271 /* gend2 is for hbb, visible xres (rest to gend1 is cut off by hblank) */
1272 gend2 = gstart + xres * plen / prescale;
1273 par->HHT = plen * (left_margin + xres + right_margin) /
1275 /* par->HHT = (gend2 + plen * right_margin / prescale) / 2 - 2;*/
1277 par->HDB = gstart - hdb_off / prescale;
1280 par->HDB += par->HHT + 2 + 0x200;
1281 par->HDE = gend1 - par->HHT - 2 - hde_off / prescale;
1282 par->HBB = gend2 - par->HHT - 2;
1284 /* One more Videl constraint: data fetch of two lines must not overlap */
1285 if ((par->HDB & 0x200) && (par->HDB & ~0x200) - par->HDE <= 5) {
1286 /* if this happens increase margins, decrease hfreq. */
1289 if (hde_off % prescale)
1290 par->HBB++; /* compensate for non matching hde and hbb */
1291 par->HSS = par->HHT + 2 - plen * hsync_len / prescale;
1292 if (par->HSS < par->HBB)
1293 par->HSS = par->HBB;
1296 /* check hor. frequency */
1297 hfreq = pclock->f / ((par->HHT + 2) * prescale * 2);
1298 if (hfreq > fb_info.monspecs.hfmax && mon_type != F_MON_VGA) {
1299 /* ++guenther: ^^^^^^^^^^^^^^^^^^^ can't remember why I did this */
1300 /* Too high -> enlarge margin */
1305 if (hfreq > fb_info.monspecs.hfmax || hfreq < fb_info.monspecs.hfmin)
1309 /* All Vxx must be odd in non-interlace, since frame starts in the middle
1310 * of the first displayed line!
1311 * One frame consists of VFT+1 half lines. VFT+1 must be even in
1312 * non-interlace, odd in interlace mode for synchronisation.
1313 * Vxx-registers are 11 bit wide
1315 par->VBE = (upper_margin * 2 + 1); /* must begin on odd halfline */
1316 par->VDB = par->VBE;
1321 par->VDE <<= 1; /* VDE now half lines per (half-)frame */
1322 par->VDE += par->VDB;
1323 par->VBB = par->VDE;
1324 par->VFT = par->VBB + (lower_margin * 2 - 1) - 1;
1325 par->VSS = par->VFT + 1 - (vsync_len * 2 - 1);
1326 /* vbb,vss,vft must be even in interlace mode */
1333 /* V-frequency check, hope I didn't create any loop here. */
1334 /* Interlace and doubleline are mutually exclusive. */
1335 vfreq = (hfreq * 2) / (par->VFT + 1);
1336 if (vfreq > fb_info.monspecs.vfmax && !doubleline && !interlace) {
1337 /* Too high -> try again with doubleline */
1340 } else if (vfreq < fb_info.monspecs.vfmin && !interlace && !doubleline) {
1341 /* Too low -> try again with interlace */
1344 } else if (vfreq < fb_info.monspecs.vfmin && doubleline) {
1345 /* Doubleline too low -> clear doubleline and enlarge margins */
1349 (hfreq * 2) / (par->VFT + 1 + 4 * lines - 2 * yres) >
1350 fb_info.monspecs.vfmax;
1353 upper_margin += lines;
1354 lower_margin += lines;
1356 } else if (vfreq > fb_info.monspecs.vfmax && doubleline) {
1357 /* Doubleline too high -> enlarge margins */
1360 (hfreq * 2) / (par->VFT + 1 + 4 * lines) >
1361 fb_info.monspecs.vfmax;
1364 upper_margin += lines;
1365 lower_margin += lines;
1367 } else if (vfreq > fb_info.monspecs.vfmax && interlace) {
1368 /* Interlace, too high -> enlarge margins */
1371 (hfreq * 2) / (par->VFT + 1 + 4 * lines) >
1372 fb_info.monspecs.vfmax;
1375 upper_margin += lines;
1376 lower_margin += lines;
1378 } else if (vfreq < fb_info.monspecs.vfmin ||
1379 vfreq > fb_info.monspecs.vfmax)
1383 linelen = xres_virtual * bpp / 8;
1384 if (yres_virtual * linelen > screen_len && screen_len)
1386 if (yres * linelen > screen_len && screen_len)
1388 if (var->yoffset + yres > yres_virtual && yres_virtual)
1390 par->yres_virtual = yres_virtual;
1391 par->screen_base = screen_base + var->yoffset * linelen;
1392 par->hw.falcon.xoffset = 0;
1394 par->next_line = linelen;
1399 static int falcon_encode_var(struct fb_var_screeninfo *var,
1400 struct atafb_par *par)
1402 /* !!! only for VGA !!! */
1405 int hdb_off, hde_off, base_off;
1406 struct falcon_hw *hw = &par->hw.falcon;
1408 memset(var, 0, sizeof(struct fb_var_screeninfo));
1409 /* possible frequencies: 25.175 or 32MHz */
1410 var->pixclock = hw->sync & 0x1 ? fext.t :
1411 hw->vid_control & VCO_CLOCK25 ? f25.t : f32.t;
1417 if (hw->vid_control & VCO_HSYPOS)
1418 var->sync |= FB_SYNC_HOR_HIGH_ACT;
1419 if (hw->vid_control & VCO_VSYPOS)
1420 var->sync |= FB_SYNC_VERT_HIGH_ACT;
1422 var->vmode = FB_VMODE_NONINTERLACED;
1423 if (hw->vid_mode & VMO_INTER)
1424 var->vmode |= FB_VMODE_INTERLACED;
1425 if (hw->vid_mode & VMO_DOUBLE)
1426 var->vmode |= FB_VMODE_DOUBLE;
1428 /* visible y resolution:
1429 * Graphics display starts at line VDB and ends at line
1430 * VDE. If interlace mode off unit of VC-registers is
1431 * half lines, else lines.
1433 var->yres = hw->vde - hw->vdb;
1434 if (!(var->vmode & FB_VMODE_INTERLACED))
1436 if (var->vmode & FB_VMODE_DOUBLE)
1440 * to get bpp, we must examine f_shift and st_shift.
1441 * f_shift is valid if any of bits no. 10, 8 or 4
1442 * is set. Priority in f_shift is: 10 ">" 8 ">" 4, i.e.
1443 * if bit 10 set then bit 8 and bit 4 don't care...
1444 * If all these bits are 0 get display depth from st_shift
1445 * (as for ST and STE)
1447 if (hw->f_shift & 0x400) /* 2 colors */
1448 var->bits_per_pixel = 1;
1449 else if (hw->f_shift & 0x100) /* hicolor */
1450 var->bits_per_pixel = 16;
1451 else if (hw->f_shift & 0x010) /* 8 bitplanes */
1452 var->bits_per_pixel = 8;
1453 else if (hw->st_shift == 0)
1454 var->bits_per_pixel = 4;
1455 else if (hw->st_shift == 0x100)
1456 var->bits_per_pixel = 2;
1457 else /* if (hw->st_shift == 0x200) */
1458 var->bits_per_pixel = 1;
1460 var->xres = hw->line_width * 16 / var->bits_per_pixel;
1461 var->xres_virtual = var->xres + hw->line_offset * 16 / var->bits_per_pixel;
1463 var->xres_virtual += 16;
1465 if (var->bits_per_pixel == 16) {
1466 var->red.offset = 11;
1467 var->red.length = 5;
1468 var->red.msb_right = 0;
1469 var->green.offset = 5;
1470 var->green.length = 6;
1471 var->green.msb_right = 0;
1472 var->blue.offset = 0;
1473 var->blue.length = 5;
1474 var->blue.msb_right = 0;
1476 var->red.offset = 0;
1477 var->red.length = hw->ste_mode ? 4 : 6;
1478 if (var->red.length > var->bits_per_pixel)
1479 var->red.length = var->bits_per_pixel;
1480 var->red.msb_right = 0;
1482 var->blue = var->green = var->red;
1484 var->transp.offset = 0;
1485 var->transp.length = 0;
1486 var->transp.msb_right = 0;
1488 linelen = var->xres_virtual * var->bits_per_pixel / 8;
1490 if (par->yres_virtual)
1491 var->yres_virtual = par->yres_virtual;
1493 /* yres_virtual == 0 means use maximum */
1494 var->yres_virtual = screen_len / linelen;
1497 var->yres_virtual = 2 * var->yres;
1499 var->yres_virtual = var->yres + hwscroll * 16;
1501 var->xoffset = 0; /* TODO change this */
1504 prescale = hxx_prescale(hw);
1505 plen = 4 >> (hw->vid_mode >> 2 & 0x3);
1506 base_off = hw->vid_control & VCO_SHORTOFFS ? 64 : 128;
1507 if (hw->f_shift & 0x100) {
1509 hdb_off = (base_off + 16 * plen) + prescale;
1511 hde_off = ((128 / var->bits_per_pixel + 2) * plen);
1513 hdb_off = (64 + base_off + (128 / var->bits_per_pixel + 2) * plen)
1516 hdb_off = (base_off + (128 / var->bits_per_pixel + 18) * plen)
1520 /* Right margin includes hsync */
1521 var->left_margin = hdb_off + prescale * ((hw->hdb & 0x1ff) -
1522 (hw->hdb & 0x200 ? 2 + hw->hht : 0));
1523 if (hw->ste_mode || mon_type != F_MON_VGA)
1524 var->right_margin = prescale * (hw->hht + 2 - hw->hde) - hde_off;
1526 /* can't use this in ste_mode, because hbb is +1 off */
1527 var->right_margin = prescale * (hw->hht + 2 - hw->hbb);
1528 var->hsync_len = prescale * (hw->hht + 2 - hw->hss);
1530 /* Lower margin includes vsync */
1531 var->upper_margin = hw->vdb / 2; /* round down to full lines */
1532 var->lower_margin = (hw->vft + 1 - hw->vde + 1) / 2; /* round up */
1533 var->vsync_len = (hw->vft + 1 - hw->vss + 1) / 2; /* round up */
1534 if (var->vmode & FB_VMODE_INTERLACED) {
1535 var->upper_margin *= 2;
1536 var->lower_margin *= 2;
1537 var->vsync_len *= 2;
1538 } else if (var->vmode & FB_VMODE_DOUBLE) {
1539 var->upper_margin = (var->upper_margin + 1) / 2;
1540 var->lower_margin = (var->lower_margin + 1) / 2;
1541 var->vsync_len = (var->vsync_len + 1) / 2;
1544 var->pixclock *= plen;
1545 var->left_margin /= plen;
1546 var->right_margin /= plen;
1547 var->hsync_len /= plen;
1549 var->right_margin -= var->hsync_len;
1550 var->lower_margin -= var->vsync_len;
1553 var->yoffset = (par->screen_base - screen_base) / linelen;
1556 var->nonstd = 0; /* what is this for? */
1561 static int f_change_mode;
1562 static struct falcon_hw f_new_mode;
1563 static int f_pan_display;
1565 static void falcon_get_par(struct atafb_par *par)
1568 struct falcon_hw *hw = &par->hw.falcon;
1570 hw->line_width = shifter_f030.scn_width;
1571 hw->line_offset = shifter_f030.off_next;
1572 hw->st_shift = videl.st_shift & 0x300;
1573 hw->f_shift = videl.f_shift;
1574 hw->vid_control = videl.control;
1575 hw->vid_mode = videl.mode;
1576 hw->sync = shifter.syncmode & 0x1;
1577 hw->xoffset = videl.xoffset & 0xf;
1578 hw->hht = videl.hht;
1579 hw->hbb = videl.hbb;
1580 hw->hbe = videl.hbe;
1581 hw->hdb = videl.hdb;
1582 hw->hde = videl.hde;
1583 hw->hss = videl.hss;
1584 hw->vft = videl.vft;
1585 hw->vbb = videl.vbb;
1586 hw->vbe = videl.vbe;
1587 hw->vdb = videl.vdb;
1588 hw->vde = videl.vde;
1589 hw->vss = videl.vss;
1591 addr = (shifter.bas_hi & 0xff) << 16 |
1592 (shifter.bas_md & 0xff) << 8 |
1593 (shifter.bas_lo & 0xff);
1594 par->screen_base = phys_to_virt(addr);
1596 /* derived parameters */
1597 hw->ste_mode = (hw->f_shift & 0x510) == 0 && hw->st_shift == 0x100;
1598 hw->mono = (hw->f_shift & 0x400) ||
1599 ((hw->f_shift & 0x510) == 0 && hw->st_shift == 0x200);
1602 static void falcon_set_par(struct atafb_par *par)
1606 /* only set screen_base if really necessary */
1607 if (current_par.screen_base != par->screen_base)
1608 fbhw->set_screen_base(par->screen_base);
1610 /* Don't touch any other registers if we keep the default resolution */
1614 /* Tell vbl-handler to change video mode.
1615 * We change modes only on next VBL, to avoid desynchronisation
1616 * (a shift to the right and wrap around by a random number of pixels
1617 * in all monochrome modes).
1618 * This seems to work on my Falcon.
1620 f_new_mode = par->hw.falcon;
1624 static irqreturn_t falcon_vbl_switcher(int irq, void *dummy)
1626 struct falcon_hw *hw = &f_new_mode;
1628 if (f_change_mode) {
1631 if (hw->sync & 0x1) {
1632 /* Enable external pixelclock. This code only for ScreenWonder */
1633 *(volatile unsigned short *)0xffff9202 = 0xffbf;
1635 /* Turn off external clocks. Read sets all output bits to 1. */
1636 *(volatile unsigned short *)0xffff9202;
1638 shifter.syncmode = hw->sync;
1640 videl.hht = hw->hht;
1641 videl.hbb = hw->hbb;
1642 videl.hbe = hw->hbe;
1643 videl.hdb = hw->hdb;
1644 videl.hde = hw->hde;
1645 videl.hss = hw->hss;
1646 videl.vft = hw->vft;
1647 videl.vbb = hw->vbb;
1648 videl.vbe = hw->vbe;
1649 videl.vdb = hw->vdb;
1650 videl.vde = hw->vde;
1651 videl.vss = hw->vss;
1653 videl.f_shift = 0; /* write enables Falcon palette, 0: 4 planes */
1655 videl.st_shift = hw->st_shift; /* write enables STE palette */
1658 * set st_shift 0, so we can tell the screen-depth if f_shift == 0.
1659 * Writing 0 to f_shift enables 4 plane Falcon mode but
1660 * doesn't set st_shift. st_shift != 0 (!= 4planes) is impossible
1661 * with Falcon palette.
1664 /* now back to Falcon palette mode */
1665 videl.f_shift = hw->f_shift;
1667 /* writing to st_shift changed scn_width and vid_mode */
1668 videl.xoffset = hw->xoffset;
1669 shifter_f030.scn_width = hw->line_width;
1670 shifter_f030.off_next = hw->line_offset;
1671 videl.control = hw->vid_control;
1672 videl.mode = hw->vid_mode;
1674 if (f_pan_display) {
1676 videl.xoffset = current_par.hw.falcon.xoffset;
1677 shifter_f030.off_next = current_par.hw.falcon.line_offset;
1682 static int falcon_pan_display(struct fb_var_screeninfo *var,
1683 struct fb_info *info)
1685 struct atafb_par *par = (struct atafb_par *)info->par;
1688 int bpp = info->var.bits_per_pixel;
1691 var->xoffset = up(var->xoffset, 32);
1693 par->hw.falcon.xoffset = var->xoffset & 15;
1695 par->hw.falcon.xoffset = 0;
1696 var->xoffset = up(var->xoffset, 2);
1698 par->hw.falcon.line_offset = bpp *
1699 (info->var.xres_virtual - info->var.xres) / 16;
1700 if (par->hw.falcon.xoffset)
1701 par->hw.falcon.line_offset -= bpp;
1702 xoffset = var->xoffset - par->hw.falcon.xoffset;
1704 par->screen_base = screen_base +
1705 (var->yoffset * info->var.xres_virtual + xoffset) * bpp / 8;
1706 if (fbhw->set_screen_base)
1707 fbhw->set_screen_base(par->screen_base);
1709 return -EINVAL; /* shouldn't happen */
1714 static int falcon_setcolreg(unsigned int regno, unsigned int red,
1715 unsigned int green, unsigned int blue,
1716 unsigned int transp, struct fb_info *info)
1720 f030_col[regno] = (((red & 0xfc00) << 16) |
1721 ((green & 0xfc00) << 8) |
1722 ((blue & 0xfc00) >> 8));
1724 shifter_tt.color_reg[regno] =
1725 (((red & 0xe000) >> 13) | ((red & 0x1000) >> 12) << 8) |
1726 (((green & 0xe000) >> 13) | ((green & 0x1000) >> 12) << 4) |
1727 ((blue & 0xe000) >> 13) | ((blue & 0x1000) >> 12);
1729 ((u32 *)info->pseudo_palette)[regno] = ((red & 0xf800) |
1730 ((green & 0xfc00) >> 5) |
1731 ((blue & 0xf800) >> 11));
1737 static int falcon_blank(int blank_mode)
1739 /* ++guenther: we can switch off graphics by changing VDB and VDE,
1740 * so VIDEL doesn't hog the bus while saving.
1741 * (this may affect usleep()).
1743 int vdb, vss, hbe, hss;
1745 if (mon_type == F_MON_SM) /* this doesn't work on SM124 */
1748 vdb = current_par.VDB;
1749 vss = current_par.VSS;
1750 hbe = current_par.HBE;
1751 hss = current_par.HSS;
1753 if (blank_mode >= 1) {
1754 /* disable graphics output (this speeds up the CPU) ... */
1755 vdb = current_par.VFT + 1;
1756 /* ... and blank all lines */
1757 hbe = current_par.HHT + 2;
1759 /* use VESA suspend modes on VGA monitors */
1760 if (mon_type == F_MON_VGA) {
1761 if (blank_mode == 2 || blank_mode == 4)
1762 vss = current_par.VFT + 1;
1763 if (blank_mode == 3 || blank_mode == 4)
1764 hss = current_par.HHT + 2;
1775 static int falcon_detect(void)
1777 struct atafb_par par;
1780 /* Determine connected monitor and set monitor parameters */
1781 fhw = *(unsigned char *)0xffff8006;
1782 mon_type = fhw >> 6 & 0x3;
1783 /* bit 1 of fhw: 1=32 bit ram bus, 0=16 bit */
1784 f030_bus_width = fhw << 6 & 0x80;
1787 fb_info.monspecs.vfmin = 70;
1788 fb_info.monspecs.vfmax = 72;
1789 fb_info.monspecs.hfmin = 35713;
1790 fb_info.monspecs.hfmax = 35715;
1795 fb_info.monspecs.vfmin = 49; /* not 50, since TOS defaults to 49.9x Hz */
1796 fb_info.monspecs.vfmax = 60;
1797 fb_info.monspecs.hfmin = 15620;
1798 fb_info.monspecs.hfmax = 15755;
1801 /* initialize hsync-len */
1802 f25.hsync = h_syncs[mon_type] / f25.t;
1803 f32.hsync = h_syncs[mon_type] / f32.t;
1805 fext.hsync = h_syncs[mon_type] / fext.t;
1807 falcon_get_par(&par);
1808 falcon_encode_var(&atafb_predefined[0], &par);
1810 /* Detected mode is always the "autodetect" slot */
1814 #endif /* ATAFB_FALCON */
1816 /* ------------------- ST(E) specific functions ---------------------- */
1820 static int stste_encode_fix(struct fb_fix_screeninfo *fix,
1821 struct atafb_par *par)
1825 strcpy(fix->id, "Atari Builtin");
1826 fix->smem_start = (unsigned long)real_screen_base;
1827 fix->smem_len = screen_len;
1828 fix->type = FB_TYPE_INTERLEAVED_PLANES;
1830 fix->visual = FB_VISUAL_PSEUDOCOLOR;
1831 mode = par->hw.st.mode & 3;
1832 if (mode == ST_HIGH) {
1833 fix->type = FB_TYPE_PACKED_PIXELS;
1835 fix->visual = FB_VISUAL_MONO10;
1837 if (ATARIHW_PRESENT(EXTD_SHIFTER)) {
1845 fix->line_length = par->next_line;
1846 fix->accel = FB_ACCEL_ATARIBLITT;
1850 static int stste_decode_var(struct fb_var_screeninfo *var,
1851 struct atafb_par *par)
1853 int xres = var->xres;
1854 int yres = var->yres;
1855 int bpp = var->bits_per_pixel;
1857 int yres_virtual = var->yres_virtual;
1860 if (bpp > 1 || xres > sttt_xres || yres > st_yres)
1862 par->hw.st.mode = ST_HIGH;
1867 if (bpp > 4 || xres > sttt_xres || yres > st_yres)
1870 if (xres > sttt_xres / 2 || yres > st_yres / 2)
1872 par->hw.st.mode = ST_LOW;
1873 xres = sttt_xres / 2;
1876 } else if (bpp > 1) {
1877 if (xres > sttt_xres || yres > st_yres / 2)
1879 par->hw.st.mode = ST_MID;
1886 if (yres_virtual <= 0)
1888 else if (yres_virtual < yres)
1889 yres_virtual = yres;
1890 if (var->sync & FB_SYNC_EXT)
1891 par->hw.st.sync = (par->hw.st.sync & ~1) | 1;
1893 par->hw.st.sync = (par->hw.st.sync & ~1);
1894 linelen = xres * bpp / 8;
1895 if (yres_virtual * linelen > screen_len && screen_len)
1897 if (yres * linelen > screen_len && screen_len)
1899 if (var->yoffset + yres > yres_virtual && yres_virtual)
1901 par->yres_virtual = yres_virtual;
1902 par->screen_base = screen_base + var->yoffset * linelen;
1903 par->next_line = linelen;
1907 static int stste_encode_var(struct fb_var_screeninfo *var,
1908 struct atafb_par *par)
1911 memset(var, 0, sizeof(struct fb_var_screeninfo));
1912 var->red.offset = 0;
1913 var->red.length = ATARIHW_PRESENT(EXTD_SHIFTER) ? 4 : 3;
1914 var->red.msb_right = 0;
1917 var->pixclock = 31041;
1918 var->left_margin = 120; /* these are incorrect */
1919 var->right_margin = 100;
1920 var->upper_margin = 8;
1921 var->lower_margin = 16;
1922 var->hsync_len = 140;
1923 var->vsync_len = 30;
1928 if (!(par->hw.st.sync & 1))
1931 var->sync = FB_SYNC_EXT;
1933 switch (par->hw.st.mode & 3) {
1935 var->xres = sttt_xres / 2;
1936 var->yres = st_yres / 2;
1937 var->bits_per_pixel = 4;
1940 var->xres = sttt_xres;
1941 var->yres = st_yres / 2;
1942 var->bits_per_pixel = 2;
1945 var->xres = sttt_xres;
1946 var->yres = st_yres;
1947 var->bits_per_pixel = 1;
1950 var->blue = var->green = var->red;
1951 var->transp.offset = 0;
1952 var->transp.length = 0;
1953 var->transp.msb_right = 0;
1954 var->xres_virtual = sttt_xres_virtual;
1955 linelen = var->xres_virtual * var->bits_per_pixel / 8;
1956 ovsc_addlen = linelen * (sttt_yres_virtual - st_yres);
1959 var->yres_virtual = var->yres;
1960 else if (screen_len) {
1961 if (par->yres_virtual)
1962 var->yres_virtual = par->yres_virtual;
1964 /* yres_virtual == 0 means use maximum */
1965 var->yres_virtual = screen_len / linelen;
1968 var->yres_virtual = 2 * var->yres;
1970 var->yres_virtual = var->yres + hwscroll * 16;
1974 var->yoffset = (par->screen_base - screen_base) / linelen;
1979 var->vmode = FB_VMODE_NONINTERLACED;
1983 static void stste_get_par(struct atafb_par *par)
1986 par->hw.st.mode = shifter_tt.st_shiftmode;
1987 par->hw.st.sync = shifter.syncmode;
1988 addr = ((shifter.bas_hi & 0xff) << 16) |
1989 ((shifter.bas_md & 0xff) << 8);
1990 if (ATARIHW_PRESENT(EXTD_SHIFTER))
1991 addr |= (shifter.bas_lo & 0xff);
1992 par->screen_base = phys_to_virt(addr);
1995 static void stste_set_par(struct atafb_par *par)
1997 shifter_tt.st_shiftmode = par->hw.st.mode;
1998 shifter.syncmode = par->hw.st.sync;
1999 /* only set screen_base if really necessary */
2000 if (current_par.screen_base != par->screen_base)
2001 fbhw->set_screen_base(par->screen_base);
2004 static int stste_setcolreg(unsigned int regno, unsigned int red,
2005 unsigned int green, unsigned int blue,
2006 unsigned int transp, struct fb_info *info)
2013 if (ATARIHW_PRESENT(EXTD_SHIFTER))
2014 shifter_tt.color_reg[regno] =
2015 (((red & 0xe) >> 1) | ((red & 1) << 3) << 8) |
2016 (((green & 0xe) >> 1) | ((green & 1) << 3) << 4) |
2017 ((blue & 0xe) >> 1) | ((blue & 1) << 3);
2019 shifter_tt.color_reg[regno] =
2020 ((red & 0xe) << 7) |
2021 ((green & 0xe) << 3) |
2022 ((blue & 0xe) >> 1);
2026 static int stste_detect(void)
2028 struct atafb_par par;
2030 /* Determine the connected monitor: The DMA sound must be
2031 * disabled before reading the MFP GPIP, because the Sound
2032 * Done Signal and the Monochrome Detect are XORed together!
2034 if (ATARIHW_PRESENT(PCM_8BIT)) {
2035 tt_dmasnd.ctrl = DMASND_CTRL_OFF;
2036 udelay(20); /* wait a while for things to settle down */
2038 mono_moni = (st_mfp.par_dt_reg & 0x80) == 0;
2040 stste_get_par(&par);
2041 stste_encode_var(&atafb_predefined[0], &par);
2043 if (!ATARIHW_PRESENT(EXTD_SHIFTER))
2048 static void stste_set_screen_base(void *s_base)
2051 addr = virt_to_phys(s_base);
2052 /* Setup Screen Memory */
2053 shifter.bas_hi = (unsigned char)((addr & 0xff0000) >> 16);
2054 shifter.bas_md = (unsigned char)((addr & 0x00ff00) >> 8);
2055 if (ATARIHW_PRESENT(EXTD_SHIFTER))
2056 shifter.bas_lo = (unsigned char)(addr & 0x0000ff);
2059 #endif /* ATAFB_STE */
2061 /* Switching the screen size should be done during vsync, otherwise
2062 * the margins may get messed up. This is a well known problem of
2063 * the ST's video system.
2065 * Unfortunately there is hardly any way to find the vsync, as the
2066 * vertical blank interrupt is no longer in time on machines with
2067 * overscan type modifications.
2069 * We can, however, use Timer B to safely detect the black shoulder,
2070 * but then we've got to guess an appropriate delay to find the vsync.
2071 * This might not work on every machine.
2073 * martin_rogge @ ki.maus.de, 8th Aug 1995
2076 #define LINE_DELAY (mono_moni ? 30 : 70)
2077 #define SYNC_DELAY (mono_moni ? 1500 : 2000)
2079 /* SWITCH_ACIA may be used for Falcon (ScreenBlaster III internal!) */
2080 static void st_ovsc_switch(void)
2082 unsigned long flags;
2083 register unsigned char old, new;
2085 if (!(atari_switches & ATARI_SWITCH_OVSC_MASK))
2087 local_irq_save(flags);
2089 st_mfp.tim_ct_b = 0x10;
2090 st_mfp.active_edge |= 8;
2091 st_mfp.tim_ct_b = 0;
2092 st_mfp.tim_dt_b = 0xf0;
2093 st_mfp.tim_ct_b = 8;
2094 while (st_mfp.tim_dt_b > 1) /* TOS does it this way, don't ask why */
2096 new = st_mfp.tim_dt_b;
2100 new = st_mfp.tim_dt_b;
2101 } while (old != new);
2102 st_mfp.tim_ct_b = 0x10;
2105 if (atari_switches & ATARI_SWITCH_OVSC_IKBD)
2106 acia.key_ctrl = ACIA_DIV64 | ACIA_D8N1S | ACIA_RHTID | ACIA_RIE;
2107 if (atari_switches & ATARI_SWITCH_OVSC_MIDI)
2108 acia.mid_ctrl = ACIA_DIV16 | ACIA_D8N1S | ACIA_RHTID;
2109 if (atari_switches & (ATARI_SWITCH_OVSC_SND6|ATARI_SWITCH_OVSC_SND7)) {
2110 sound_ym.rd_data_reg_sel = 14;
2111 sound_ym.wd_data = sound_ym.rd_data_reg_sel |
2112 ((atari_switches & ATARI_SWITCH_OVSC_SND6) ? 0x40:0) |
2113 ((atari_switches & ATARI_SWITCH_OVSC_SND7) ? 0x80:0);
2115 local_irq_restore(flags);
2118 /* ------------------- External Video ---------------------- */
2122 static int ext_encode_fix(struct fb_fix_screeninfo *fix, struct atafb_par *par)
2124 strcpy(fix->id, "Unknown Extern");
2125 fix->smem_start = (unsigned long)external_addr;
2126 fix->smem_len = PAGE_ALIGN(external_len);
2127 if (external_depth == 1) {
2128 fix->type = FB_TYPE_PACKED_PIXELS;
2129 /* The letters 'n' and 'i' in the "atavideo=external:" stand
2130 * for "normal" and "inverted", rsp., in the monochrome case */
2132 (external_pmode == FB_TYPE_INTERLEAVED_PLANES ||
2133 external_pmode == FB_TYPE_PACKED_PIXELS) ?
2134 FB_VISUAL_MONO10 : FB_VISUAL_MONO01;
2136 /* Use STATIC if we don't know how to access color registers */
2137 int visual = external_vgaiobase ?
2138 FB_VISUAL_PSEUDOCOLOR :
2139 FB_VISUAL_STATIC_PSEUDOCOLOR;
2140 switch (external_pmode) {
2141 case -1: /* truecolor */
2142 fix->type = FB_TYPE_PACKED_PIXELS;
2143 fix->visual = FB_VISUAL_TRUECOLOR;
2145 case FB_TYPE_PACKED_PIXELS:
2146 fix->type = FB_TYPE_PACKED_PIXELS;
2147 fix->visual = visual;
2149 case FB_TYPE_PLANES:
2150 fix->type = FB_TYPE_PLANES;
2151 fix->visual = visual;
2153 case FB_TYPE_INTERLEAVED_PLANES:
2154 fix->type = FB_TYPE_INTERLEAVED_PLANES;
2156 fix->visual = visual;
2163 fix->line_length = par->next_line;
2167 static int ext_decode_var(struct fb_var_screeninfo *var, struct atafb_par *par)
2169 struct fb_var_screeninfo *myvar = &atafb_predefined[0];
2171 if (var->bits_per_pixel > myvar->bits_per_pixel ||
2172 var->xres > myvar->xres ||
2173 var->xres_virtual > myvar->xres_virtual ||
2174 var->yres > myvar->yres ||
2179 par->next_line = external_xres_virtual * external_depth / 8;
2183 static int ext_encode_var(struct fb_var_screeninfo *var, struct atafb_par *par)
2185 memset(var, 0, sizeof(struct fb_var_screeninfo));
2186 var->red.offset = 0;
2187 var->red.length = (external_pmode == -1) ? external_depth / 3 :
2188 (external_vgaiobase ? external_bitspercol : 0);
2189 var->red.msb_right = 0;
2192 var->pixclock = 31041;
2193 var->left_margin = 120; /* these are surely incorrect */
2194 var->right_margin = 100;
2195 var->upper_margin = 8;
2196 var->lower_margin = 16;
2197 var->hsync_len = 140;
2198 var->vsync_len = 30;
2205 var->xres = external_xres;
2206 var->yres = external_yres;
2207 var->xres_virtual = external_xres_virtual;
2208 var->bits_per_pixel = external_depth;
2210 var->blue = var->green = var->red;
2211 var->transp.offset = 0;
2212 var->transp.length = 0;
2213 var->transp.msb_right = 0;
2214 var->yres_virtual = var->yres;
2219 var->vmode = FB_VMODE_NONINTERLACED;
2223 static void ext_get_par(struct atafb_par *par)
2225 par->screen_base = external_addr;
2228 static void ext_set_par(struct atafb_par *par)
2232 #define OUTB(port,val) \
2233 *((unsigned volatile char *) ((port)+external_vgaiobase)) = (val)
2235 (*((unsigned volatile char *) ((port)+external_vgaiobase)))
2238 unsigned char tmp = INB(0x3da); \
2242 static int ext_setcolreg(unsigned int regno, unsigned int red,
2243 unsigned int green, unsigned int blue,
2244 unsigned int transp, struct fb_info *info)
2246 unsigned char colmask = (1 << external_bitspercol) - 1;
2248 if (!external_vgaiobase)
2251 switch (external_card_type) {
2255 OUTB(0x3c9, red & colmask);
2257 OUTB(0x3c9, green & colmask);
2259 OUTB(0x3c9, blue & colmask);
2264 OUTB((MV300_reg[regno] << 2) + 1, red);
2265 OUTB((MV300_reg[regno] << 2) + 1, green);
2266 OUTB((MV300_reg[regno] << 2) + 1, blue);
2274 static int ext_detect(void)
2276 struct fb_var_screeninfo *myvar = &atafb_predefined[0];
2277 struct atafb_par dummy_par;
2279 myvar->xres = external_xres;
2280 myvar->xres_virtual = external_xres_virtual;
2281 myvar->yres = external_yres;
2282 myvar->bits_per_pixel = external_depth;
2283 ext_encode_var(myvar, &dummy_par);
2287 #endif /* ATAFB_EXT */
2289 /* ------ This is the same for most hardware types -------- */
2291 static void set_screen_base(void *s_base)
2295 addr = virt_to_phys(s_base);
2296 /* Setup Screen Memory */
2297 shifter.bas_hi = (unsigned char)((addr & 0xff0000) >> 16);
2298 shifter.bas_md = (unsigned char)((addr & 0x00ff00) >> 8);
2299 shifter.bas_lo = (unsigned char)(addr & 0x0000ff);
2302 static int pan_display(struct fb_var_screeninfo *var, struct fb_info *info)
2304 struct atafb_par *par = (struct atafb_par *)info->par;
2306 if (!fbhw->set_screen_base ||
2307 (!ATARIHW_PRESENT(EXTD_SHIFTER) && var->xoffset))
2309 var->xoffset = up(var->xoffset, 16);
2310 par->screen_base = screen_base +
2311 (var->yoffset * info->var.xres_virtual + var->xoffset)
2312 * info->var.bits_per_pixel / 8;
2313 fbhw->set_screen_base(par->screen_base);
2317 /* ------------ Interfaces to hardware functions ------------ */
2320 static struct fb_hwswitch tt_switch = {
2321 .detect = tt_detect,
2322 .encode_fix = tt_encode_fix,
2323 .decode_var = tt_decode_var,
2324 .encode_var = tt_encode_var,
2325 .get_par = tt_get_par,
2326 .set_par = tt_set_par,
2327 .set_screen_base = set_screen_base,
2328 .pan_display = pan_display,
2333 static struct fb_hwswitch falcon_switch = {
2334 .detect = falcon_detect,
2335 .encode_fix = falcon_encode_fix,
2336 .decode_var = falcon_decode_var,
2337 .encode_var = falcon_encode_var,
2338 .get_par = falcon_get_par,
2339 .set_par = falcon_set_par,
2340 .set_screen_base = set_screen_base,
2341 .blank = falcon_blank,
2342 .pan_display = falcon_pan_display,
2347 static struct fb_hwswitch st_switch = {
2348 .detect = stste_detect,
2349 .encode_fix = stste_encode_fix,
2350 .decode_var = stste_decode_var,
2351 .encode_var = stste_encode_var,
2352 .get_par = stste_get_par,
2353 .set_par = stste_set_par,
2354 .set_screen_base = stste_set_screen_base,
2355 .pan_display = pan_display
2360 static struct fb_hwswitch ext_switch = {
2361 .detect = ext_detect,
2362 .encode_fix = ext_encode_fix,
2363 .decode_var = ext_decode_var,
2364 .encode_var = ext_encode_var,
2365 .get_par = ext_get_par,
2366 .set_par = ext_set_par,
2370 static void ata_get_par(struct atafb_par *par)
2372 if (current_par_valid)
2378 static void ata_set_par(struct atafb_par *par)
2382 current_par_valid = 1;
2386 /* =========================================================== */
2387 /* ============== Hardware Independent Functions ============= */
2388 /* =========================================================== */
2390 /* used for hardware scrolling */
2392 static int do_fb_set_var(struct fb_var_screeninfo *var, int isactive)
2395 struct atafb_par par;
2397 err = fbhw->decode_var(var, &par);
2400 activate = var->activate;
2401 if (((var->activate & FB_ACTIVATE_MASK) == FB_ACTIVATE_NOW) && isactive)
2403 fbhw->encode_var(var, &par);
2404 var->activate = activate;
2408 static int atafb_get_fix(struct fb_fix_screeninfo *fix, struct fb_info *info)
2410 struct atafb_par par;
2412 // Get fix directly (case con == -1 before)??
2413 err = fbhw->decode_var(&info->var, &par);
2416 memset(fix, 0, sizeof(struct fb_fix_screeninfo));
2417 mutex_lock(&info->mm_lock);
2418 err = fbhw->encode_fix(fix, &par);
2419 mutex_unlock(&info->mm_lock);
2423 static int atafb_get_var(struct fb_var_screeninfo *var, struct fb_info *info)
2425 struct atafb_par par;
2428 fbhw->encode_var(var, &par);
2433 // No longer called by fbcon!
2434 // Still called by set_var internally
2436 static void atafb_set_disp(struct fb_info *info)
2438 atafb_get_var(&info->var, info);
2439 atafb_get_fix(&info->fix, info);
2441 info->screen_base = (void *)info->fix.smem_start;
2444 static int atafb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
2445 u_int transp, struct fb_info *info)
2451 return info->fbops->fb_setcolreg(regno, red, green, blue, transp, info);
2455 atafb_pan_display(struct fb_var_screeninfo *var, struct fb_info *info)
2457 int xoffset = var->xoffset;
2458 int yoffset = var->yoffset;
2461 if (var->vmode & FB_VMODE_YWRAP) {
2462 if (yoffset < 0 || yoffset >= info->var.yres_virtual || xoffset)
2465 if (xoffset + info->var.xres > info->var.xres_virtual ||
2466 yoffset + info->var.yres > info->var.yres_virtual)
2470 if (fbhw->pan_display) {
2471 err = fbhw->pan_display(var, info);
2477 info->var.xoffset = xoffset;
2478 info->var.yoffset = yoffset;
2480 if (var->vmode & FB_VMODE_YWRAP)
2481 info->var.vmode |= FB_VMODE_YWRAP;
2483 info->var.vmode &= ~FB_VMODE_YWRAP;
2489 * generic drawing routines; imageblit needs updating for image depth > 1
2492 #if BITS_PER_LONG == 32
2493 #define BYTES_PER_LONG 4
2494 #define SHIFT_PER_LONG 5
2495 #elif BITS_PER_LONG == 64
2496 #define BYTES_PER_LONG 8
2497 #define SHIFT_PER_LONG 6
2499 #define Please update me
2503 static void atafb_fillrect(struct fb_info *info, const struct fb_fillrect *rect)
2505 struct atafb_par *par = (struct atafb_par *)info->par;
2509 if (!rect->width || !rect->height)
2513 if (info->var.bits_per_pixel == 16) {
2514 cfb_fillrect(info, rect);
2520 * We could use hardware clipping but on many cards you get around
2521 * hardware clipping by writing to framebuffer directly.
2523 x2 = rect->dx + rect->width;
2524 y2 = rect->dy + rect->height;
2525 x2 = x2 < info->var.xres_virtual ? x2 : info->var.xres_virtual;
2526 y2 = y2 < info->var.yres_virtual ? y2 : info->var.yres_virtual;
2527 width = x2 - rect->dx;
2528 height = y2 - rect->dy;
2530 if (info->var.bits_per_pixel == 1)
2531 atafb_mfb_fillrect(info, par->next_line, rect->color,
2532 rect->dy, rect->dx, height, width);
2533 else if (info->var.bits_per_pixel == 2)
2534 atafb_iplan2p2_fillrect(info, par->next_line, rect->color,
2535 rect->dy, rect->dx, height, width);
2536 else if (info->var.bits_per_pixel == 4)
2537 atafb_iplan2p4_fillrect(info, par->next_line, rect->color,
2538 rect->dy, rect->dx, height, width);
2540 atafb_iplan2p8_fillrect(info, par->next_line, rect->color,
2541 rect->dy, rect->dx, height, width);
2546 static void atafb_copyarea(struct fb_info *info, const struct fb_copyarea *area)
2548 struct atafb_par *par = (struct atafb_par *)info->par;
2550 u32 dx, dy, sx, sy, width, height;
2554 if (info->var.bits_per_pixel == 16) {
2555 cfb_copyarea(info, area);
2560 /* clip the destination */
2561 x2 = area->dx + area->width;
2562 y2 = area->dy + area->height;
2563 dx = area->dx > 0 ? area->dx : 0;
2564 dy = area->dy > 0 ? area->dy : 0;
2565 x2 = x2 < info->var.xres_virtual ? x2 : info->var.xres_virtual;
2566 y2 = y2 < info->var.yres_virtual ? y2 : info->var.yres_virtual;
2570 if (area->sx + dx < area->dx || area->sy + dy < area->dy)
2574 sx = area->sx + (dx - area->dx);
2575 sy = area->sy + (dy - area->dy);
2577 /* the source must be completely inside the virtual screen */
2578 if (sx + width > info->var.xres_virtual ||
2579 sy + height > info->var.yres_virtual)
2582 if (dy > sy || (dy == sy && dx > sx)) {
2588 if (info->var.bits_per_pixel == 1)
2589 atafb_mfb_copyarea(info, par->next_line, sy, sx, dy, dx, height, width);
2590 else if (info->var.bits_per_pixel == 2)
2591 atafb_iplan2p2_copyarea(info, par->next_line, sy, sx, dy, dx, height, width);
2592 else if (info->var.bits_per_pixel == 4)
2593 atafb_iplan2p4_copyarea(info, par->next_line, sy, sx, dy, dx, height, width);
2595 atafb_iplan2p8_copyarea(info, par->next_line, sy, sx, dy, dx, height, width);
2600 static void atafb_imageblit(struct fb_info *info, const struct fb_image *image)
2602 struct atafb_par *par = (struct atafb_par *)info->par;
2607 u32 dx, dy, width, height, pitch;
2610 if (info->var.bits_per_pixel == 16) {
2611 cfb_imageblit(info, image);
2617 * We could use hardware clipping but on many cards you get around
2618 * hardware clipping by writing to framebuffer directly like we are
2621 x2 = image->dx + image->width;
2622 y2 = image->dy + image->height;
2625 x2 = x2 < info->var.xres_virtual ? x2 : info->var.xres_virtual;
2626 y2 = y2 < info->var.yres_virtual ? y2 : info->var.yres_virtual;
2630 if (image->depth == 1) {
2631 // used for font data
2632 dst = (unsigned long *)
2633 ((unsigned long)info->screen_base & ~(BYTES_PER_LONG - 1));
2634 dst_idx = ((unsigned long)info->screen_base & (BYTES_PER_LONG - 1)) * 8;
2635 dst_idx += dy * par->next_line * 8 + dx;
2637 pitch = (image->width + 7) / 8;
2640 if (info->var.bits_per_pixel == 1)
2641 atafb_mfb_linefill(info, par->next_line,
2643 image->bg_color, image->fg_color);
2644 else if (info->var.bits_per_pixel == 2)
2645 atafb_iplan2p2_linefill(info, par->next_line,
2647 image->bg_color, image->fg_color);
2648 else if (info->var.bits_per_pixel == 4)
2649 atafb_iplan2p4_linefill(info, par->next_line,
2651 image->bg_color, image->fg_color);
2653 atafb_iplan2p8_linefill(info, par->next_line,
2655 image->bg_color, image->fg_color);
2660 c2p_iplan2(info->screen_base, image->data, dx, dy, width,
2661 height, par->next_line, image->width,
2662 info->var.bits_per_pixel);
2667 atafb_ioctl(struct fb_info *info, unsigned int cmd, unsigned long arg)
2670 #ifdef FBCMD_GET_CURRENTPAR
2671 case FBCMD_GET_CURRENTPAR:
2672 if (copy_to_user((void *)arg, (void *)¤t_par,
2673 sizeof(struct atafb_par)))
2677 #ifdef FBCMD_SET_CURRENTPAR
2678 case FBCMD_SET_CURRENTPAR:
2679 if (copy_from_user((void *)¤t_par, (void *)arg,
2680 sizeof(struct atafb_par)))
2682 ata_set_par(¤t_par);
2689 /* (un)blank/poweroff
2696 static int atafb_blank(int blank, struct fb_info *info)
2698 unsigned short black[16];
2699 struct fb_cmap cmap;
2700 if (fbhw->blank && !fbhw->blank(blank))
2703 memset(black, 0, 16 * sizeof(unsigned short));
2710 fb_set_cmap(&cmap, info);
2714 do_install_cmap(info);
2720 * New fbcon interface ...
2723 /* check var by decoding var into hw par, rounding if necessary,
2724 * then encoding hw par back into new, validated var */
2725 static int atafb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
2728 struct atafb_par par;
2730 /* Validate wanted screen parameters */
2731 // if ((err = ata_decode_var(var, &par)))
2732 err = fbhw->decode_var(var, &par);
2736 /* Encode (possibly rounded) screen parameters */
2737 fbhw->encode_var(var, &par);
2741 /* actually set hw par by decoding var, then setting hardware from
2742 * hw par just decoded */
2743 static int atafb_set_par(struct fb_info *info)
2745 struct atafb_par *par = (struct atafb_par *)info->par;
2747 /* Decode wanted screen parameters */
2748 fbhw->decode_var(&info->var, par);
2749 mutex_lock(&info->mm_lock);
2750 fbhw->encode_fix(&info->fix, par);
2751 mutex_unlock(&info->mm_lock);
2753 /* Set new videomode */
2760 static struct fb_ops atafb_ops = {
2761 .owner = THIS_MODULE,
2762 .fb_check_var = atafb_check_var,
2763 .fb_set_par = atafb_set_par,
2764 .fb_setcolreg = atafb_setcolreg,
2765 .fb_blank = atafb_blank,
2766 .fb_pan_display = atafb_pan_display,
2767 .fb_fillrect = atafb_fillrect,
2768 .fb_copyarea = atafb_copyarea,
2769 .fb_imageblit = atafb_imageblit,
2770 .fb_ioctl = atafb_ioctl,
2773 static void check_default_par(int detected_mode)
2775 char default_name[10];
2777 struct fb_var_screeninfo var;
2778 unsigned long min_mem;
2780 /* First try the user supplied mode */
2782 var = atafb_predefined[default_par - 1];
2783 var.activate = FB_ACTIVATE_TEST;
2784 if (do_fb_set_var(&var, 1))
2785 default_par = 0; /* failed */
2787 /* Next is the autodetected one */
2789 var = atafb_predefined[detected_mode - 1]; /* autodetect */
2790 var.activate = FB_ACTIVATE_TEST;
2791 if (!do_fb_set_var(&var, 1))
2792 default_par = detected_mode;
2794 /* If that also failed, try some default modes... */
2796 /* try default1, default2... */
2797 for (i = 1; i < 10; i++) {
2798 sprintf(default_name,"default%d", i);
2799 default_par = get_video_mode(default_name);
2801 panic("can't set default video mode");
2802 var = atafb_predefined[default_par - 1];
2803 var.activate = FB_ACTIVATE_TEST;
2804 if (!do_fb_set_var(&var,1))
2808 min_mem = var.xres_virtual * var.yres_virtual * var.bits_per_pixel / 8;
2809 if (default_mem_req < min_mem)
2810 default_mem_req = min_mem;
2814 static void __init atafb_setup_ext(char *spec)
2816 int xres, xres_virtual, yres, depth, planes;
2817 unsigned long addr, len;
2820 /* Format is: <xres>;<yres>;<depth>;<plane organ.>;
2822 * [;<screen mem length>[;<vgaiobase>[;<bits-per-col>[;<colorreg-type>
2823 * [;<xres-virtual>]]]]]
2826 * <xres_virtual>: hardware's x-resolution (f.e. ProMST)
2828 * Even xres_virtual is available, we neither support panning nor hw-scrolling!
2830 p = strsep(&spec, ";");
2833 xres_virtual = xres = simple_strtoul(p, NULL, 10);
2837 p = strsep(&spec, ";");
2840 yres = simple_strtoul(p, NULL, 10);
2844 p = strsep(&spec, ";");
2847 depth = simple_strtoul(p, NULL, 10);
2848 if (depth != 1 && depth != 2 && depth != 4 && depth != 8 &&
2849 depth != 16 && depth != 24)
2852 p = strsep(&spec, ";");
2856 planes = FB_TYPE_INTERLEAVED_PLANES;
2858 planes = FB_TYPE_PACKED_PIXELS;
2860 planes = FB_TYPE_PLANES;
2862 planes = -1; /* true color */
2866 p = strsep(&spec, ";");
2869 addr = simple_strtoul(p, NULL, 0);
2871 p = strsep(&spec, ";");
2873 len = xres * yres * depth / 8;
2875 len = simple_strtoul(p, NULL, 0);
2877 p = strsep(&spec, ";");
2879 external_vgaiobase = simple_strtoul(p, NULL, 0);
2881 p = strsep(&spec, ";");
2883 external_bitspercol = simple_strtoul(p, NULL, 0);
2884 if (external_bitspercol > 8)
2885 external_bitspercol = 8;
2886 else if (external_bitspercol < 1)
2887 external_bitspercol = 1;
2890 p = strsep(&spec, ";");
2892 if (!strcmp(p, "vga"))
2893 external_card_type = IS_VGA;
2894 if (!strcmp(p, "mv300"))
2895 external_card_type = IS_MV300;
2898 p = strsep(&spec, ";");
2900 xres_virtual = simple_strtoul(p, NULL, 10);
2901 if (xres_virtual < xres)
2902 xres_virtual = xres;
2903 if (xres_virtual * yres * depth / 8 > len)
2904 len = xres_virtual * yres * depth / 8;
2907 external_xres = xres;
2908 external_xres_virtual = xres_virtual;
2909 external_yres = yres;
2910 external_depth = depth;
2911 external_pmode = planes;
2912 external_addr = (void *)addr;
2915 if (external_card_type == IS_MV300) {
2916 switch (external_depth) {
2918 MV300_reg = MV300_reg_1bit;
2921 MV300_reg = MV300_reg_4bit;
2924 MV300_reg = MV300_reg_8bit;
2929 #endif /* ATAFB_EXT */
2931 static void __init atafb_setup_int(char *spec)
2933 /* Format to config extended internal video hardware like OverScan:
2934 * "internal:<xres>;<yres>;<xres_max>;<yres_max>;<offset>"
2936 * <xres>: x-resolution
2937 * <yres>: y-resolution
2938 * The following are only needed if you have an overscan which
2939 * needs a black border:
2940 * <xres_max>: max. length of a line in pixels your OverScan hardware would allow
2941 * <yres_max>: max. number of lines your OverScan hardware would allow
2942 * <offset>: Offset from physical beginning to visible beginning
2943 * of screen in bytes
2948 if (!(p = strsep(&spec, ";")) || !*p)
2950 xres = simple_strtoul(p, NULL, 10);
2951 if (!(p = strsep(&spec, ";")) || !*p)
2954 tt_yres = st_yres = simple_strtoul(p, NULL, 10);
2955 if ((p = strsep(&spec, ";")) && *p)
2956 sttt_xres_virtual = simple_strtoul(p, NULL, 10);
2957 if ((p = strsep(&spec, ";")) && *p)
2958 sttt_yres_virtual = simple_strtoul(p, NULL, 0);
2959 if ((p = strsep(&spec, ";")) && *p)
2960 ovsc_offset = simple_strtoul(p, NULL, 0);
2962 if (ovsc_offset || (sttt_yres_virtual != st_yres))
2967 static void __init atafb_setup_mcap(char *spec)
2970 int vmin, vmax, hmin, hmax;
2972 /* Format for monitor capabilities is: <Vmin>;<Vmax>;<Hmin>;<Hmax>
2973 * <V*> vertical freq. in Hz
2974 * <H*> horizontal freq. in kHz
2976 if (!(p = strsep(&spec, ";")) || !*p)
2978 vmin = simple_strtoul(p, NULL, 10);
2981 if (!(p = strsep(&spec, ";")) || !*p)
2983 vmax = simple_strtoul(p, NULL, 10);
2984 if (vmax <= 0 || vmax <= vmin)
2986 if (!(p = strsep(&spec, ";")) || !*p)
2988 hmin = 1000 * simple_strtoul(p, NULL, 10);
2991 if (!(p = strsep(&spec, "")) || !*p)
2993 hmax = 1000 * simple_strtoul(p, NULL, 10);
2994 if (hmax <= 0 || hmax <= hmin)
2997 fb_info.monspecs.vfmin = vmin;
2998 fb_info.monspecs.vfmax = vmax;
2999 fb_info.monspecs.hfmin = hmin;
3000 fb_info.monspecs.hfmax = hmax;
3002 #endif /* ATAFB_FALCON */
3004 static void __init atafb_setup_user(char *spec)
3006 /* Format of user defined video mode is: <xres>;<yres>;<depth>
3009 int xres, yres, depth, temp;
3011 p = strsep(&spec, ";");
3014 xres = simple_strtoul(p, NULL, 10);
3015 p = strsep(&spec, ";");
3018 yres = simple_strtoul(p, NULL, 10);
3019 p = strsep(&spec, "");
3022 depth = simple_strtoul(p, NULL, 10);
3023 temp = get_video_mode("user0");
3026 atafb_predefined[default_par - 1].xres = xres;
3027 atafb_predefined[default_par - 1].yres = yres;
3028 atafb_predefined[default_par - 1].bits_per_pixel = depth;
3032 int __init atafb_setup(char *options)
3037 if (!options || !*options)
3040 while ((this_opt = strsep(&options, ",")) != NULL) {
3043 if ((temp = get_video_mode(this_opt))) {
3045 mode_option = this_opt;
3046 } else if (!strcmp(this_opt, "inverse"))
3048 else if (!strncmp(this_opt, "hwscroll_", 9)) {
3049 hwscroll = simple_strtoul(this_opt + 9, NULL, 10);
3056 else if (!strcmp(this_opt, "mv300")) {
3057 external_bitspercol = 8;
3058 external_card_type = IS_MV300;
3059 } else if (!strncmp(this_opt, "external:", 9))
3060 atafb_setup_ext(this_opt + 9);
3062 else if (!strncmp(this_opt, "internal:", 9))
3063 atafb_setup_int(this_opt + 9);
3065 else if (!strncmp(this_opt, "eclock:", 7)) {
3066 fext.f = simple_strtoul(this_opt + 7, NULL, 10);
3067 /* external pixelclock in kHz --> ps */
3068 fext.t = 1000000000 / fext.f;
3070 } else if (!strncmp(this_opt, "monitorcap:", 11))
3071 atafb_setup_mcap(this_opt + 11);
3073 else if (!strcmp(this_opt, "keep"))
3075 else if (!strncmp(this_opt, "R", 1))
3076 atafb_setup_user(this_opt + 1);
3081 int __init atafb_init(void)
3083 int pad, detected_mode, error;
3084 unsigned int defmode = 0;
3085 unsigned long mem_req;
3088 char *option = NULL;
3090 if (fb_get_options("atafb", &option))
3092 atafb_setup(option);
3094 printk("atafb_init: start\n");
3101 if (external_addr) {
3102 printk("atafb_init: initializing external hw\n");
3104 atafb_ops.fb_setcolreg = &ext_setcolreg;
3105 defmode = DEFMODE_EXT;
3110 if (ATARIHW_PRESENT(TT_SHIFTER)) {
3111 printk("atafb_init: initializing TT hw\n");
3113 atafb_ops.fb_setcolreg = &tt_setcolreg;
3114 defmode = DEFMODE_TT;
3119 if (ATARIHW_PRESENT(VIDEL_SHIFTER)) {
3120 printk("atafb_init: initializing Falcon hw\n");
3121 fbhw = &falcon_switch;
3122 atafb_ops.fb_setcolreg = &falcon_setcolreg;
3123 error = request_irq(IRQ_AUTO_4, falcon_vbl_switcher,
3125 "framebuffer/modeswitch",
3126 falcon_vbl_switcher);
3129 defmode = DEFMODE_F30;
3134 if (ATARIHW_PRESENT(STND_SHIFTER) ||
3135 ATARIHW_PRESENT(EXTD_SHIFTER)) {
3136 printk("atafb_init: initializing ST/E hw\n");
3138 atafb_ops.fb_setcolreg = &stste_setcolreg;
3139 defmode = DEFMODE_STE;
3143 atafb_ops.fb_setcolreg = &stste_setcolreg;
3144 printk("Cannot determine video hardware; defaulting to ST(e)\n");
3145 #else /* ATAFB_STE */
3146 /* no default driver included */
3147 /* Nobody will ever see this message :-) */
3148 panic("Cannot initialize video hardware");
3152 /* Multisync monitor capabilities */
3153 /* Atari-TOS defaults if no boot option present */
3154 if (fb_info.monspecs.hfmin == 0) {
3155 fb_info.monspecs.hfmin = 31000;
3156 fb_info.monspecs.hfmax = 32000;
3157 fb_info.monspecs.vfmin = 58;
3158 fb_info.monspecs.vfmax = 62;
3161 detected_mode = fbhw->detect();
3162 check_default_par(detected_mode);
3164 if (!external_addr) {
3165 #endif /* ATAFB_EXT */
3166 mem_req = default_mem_req + ovsc_offset + ovsc_addlen;
3167 mem_req = PAGE_ALIGN(mem_req) + PAGE_SIZE;
3168 screen_base = atari_stram_alloc(mem_req, "atafb");
3170 panic("Cannot allocate screen memory");
3171 memset(screen_base, 0, mem_req);
3172 pad = -(unsigned long)screen_base & (PAGE_SIZE - 1);
3174 real_screen_base = screen_base + ovsc_offset;
3175 screen_len = (mem_req - pad - ovsc_offset) & PAGE_MASK;
3177 if (CPU_IS_040_OR_060) {
3178 /* On a '040+, the cache mode of video RAM must be set to
3179 * write-through also for internal video hardware! */
3180 cache_push(virt_to_phys(screen_base), screen_len);
3181 kernel_set_cachemode(screen_base, screen_len,
3182 IOMAP_WRITETHROUGH);
3184 printk("atafb: screen_base %p real_screen_base %p screen_len %d\n",
3185 screen_base, real_screen_base, screen_len);
3188 /* Map the video memory (physical address given) to somewhere
3189 * in the kernel address space.
3191 external_addr = ioremap_writethrough((unsigned long)external_addr,
3193 if (external_vgaiobase)
3194 external_vgaiobase =
3195 (unsigned long)ioremap(external_vgaiobase, 0x10000);
3197 real_screen_base = external_addr;
3198 screen_len = external_len & PAGE_MASK;
3199 memset (screen_base, 0, external_len);
3201 #endif /* ATAFB_EXT */
3203 // strcpy(fb_info.mode->name, "Atari Builtin ");
3204 fb_info.fbops = &atafb_ops;
3205 // try to set default (detected; requested) var
3206 do_fb_set_var(&atafb_predefined[default_par - 1], 1);
3207 // reads hw state into current par, which may not be sane yet
3208 ata_get_par(¤t_par);
3209 fb_info.par = ¤t_par;
3210 // tries to read from HW which may not be initialized yet
3211 // so set sane var first, then call atafb_set_par
3212 atafb_get_var(&fb_info.var, &fb_info);
3215 fb_info.pseudo_palette = current_par.hw.falcon.pseudo_palette;
3217 fb_info.flags = FBINFO_FLAG_DEFAULT;
3219 if (!fb_find_mode(&fb_info.var, &fb_info, mode_option, atafb_modedb,
3220 NUM_TOTAL_MODES, &atafb_modedb[defmode],
3221 fb_info.var.bits_per_pixel)) {
3225 fb_videomode_to_modelist(atafb_modedb, NUM_TOTAL_MODES,
3228 atafb_set_disp(&fb_info);
3230 fb_alloc_cmap(&(fb_info.cmap), 1 << fb_info.var.bits_per_pixel, 0);
3233 printk("Determined %dx%d, depth %d\n",
3234 fb_info.var.xres, fb_info.var.yres, fb_info.var.bits_per_pixel);
3235 if ((fb_info.var.xres != fb_info.var.xres_virtual) ||
3236 (fb_info.var.yres != fb_info.var.yres_virtual))
3237 printk(" virtual %dx%d\n", fb_info.var.xres_virtual,
3238 fb_info.var.yres_virtual);
3240 if (register_framebuffer(&fb_info) < 0) {
3242 if (external_addr) {
3243 iounmap(external_addr);
3244 external_addr = NULL;
3246 if (external_vgaiobase) {
3247 iounmap((void*)external_vgaiobase);
3248 external_vgaiobase = 0;
3254 // FIXME: mode needs setting!
3255 //printk("fb%d: %s frame buffer device, using %dK of video memory\n",
3256 // fb_info.node, fb_info.mode->name, screen_len>>10);
3257 printk("fb%d: frame buffer device, using %dK of video memory\n",
3258 fb_info.node, screen_len >> 10);
3260 /* TODO: This driver cannot be unloaded yet */
3264 module_init(atafb_init);
3267 MODULE_LICENSE("GPL");
3269 int cleanup_module(void)
3271 unregister_framebuffer(&fb_info);
3272 return atafb_deinit();