?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[TG3]: Set minimal hw interrupt mitigation.
[linux-2.6/verdex.git] / drivers / video / atafb.c
blob15ec1295bc294eefea5a3d8ba049467a2f336f48
1 /*
2 * linux/drivers/video/atafb.c -- Atari builtin chipset frame buffer device
3 *
4 * Copyright (C) 1994 Martin Schaller & Roman Hodek
5 *
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
8 * for more details.
9 *
10 * History:
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
31 * supported.
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
38 *
39 * To do:
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.
42 *
43 */
44
45 #define ATAFB_TT
46 #define ATAFB_STE
47 #define ATAFB_EXT
48 #define ATAFB_FALCON
49
50 #include <linux/module.h>
51 #include <linux/kernel.h>
52 #include <linux/sched.h>
53 #include <linux/errno.h>
54 #include <linux/string.h>
55 #include <linux/mm.h>
56 #include <linux/tty.h>
57 #include <linux/slab.h>
58 #include <linux/delay.h>
59 #include <linux/init.h>
60 #include <linux/interrupt.h>
61
62 #include <asm/setup.h>
63 #include <asm/uaccess.h>
64 #include <asm/pgtable.h>
65 #include <asm/irq.h>
66 #include <asm/io.h>
67
68 #include <asm/atarihw.h>
69 #include <asm/atariints.h>
70 #include <asm/atari_stram.h>
71
72 #include <linux/fb.h>
73 #include <asm/atarikb.h>
74
75 #include <video/fbcon.h>
76 #include <video/fbcon-cfb8.h>
77 #include <video/fbcon-cfb16.h>
78 #include <video/fbcon-iplan2p2.h>
79 #include <video/fbcon-iplan2p4.h>
80 #include <video/fbcon-iplan2p8.h>
81 #include <video/fbcon-mfb.h>
82
83
84 #define SWITCH_ACIA 0x01 /* modes for switch on OverScan */
85 #define SWITCH_SND6 0x40
86 #define SWITCH_SND7 0x80
87 #define SWITCH_NONE 0x00
88
89
90 #define up(x, r) (((x) + (r) - 1) & ~((r)-1))
91
92
93 static int default_par=0; /* default resolution (0=none) */
94
95 static unsigned long default_mem_req=0;
96
97 static int hwscroll=-1;
98
99 static int use_hwscroll = 1;
100
101 static int sttt_xres=640,st_yres=400,tt_yres=480;
102 static int sttt_xres_virtual=640,sttt_yres_virtual=400;
103 static int ovsc_offset=0, ovsc_addlen=0;
104
105 static struct atafb_par {
106 void *screen_base;
107 int yres_virtual;
108 #if defined ATAFB_TT || defined ATAFB_STE
109 union {
110 struct {
111 int mode;
112 int sync;
113 } tt, st;
114 #endif
115 #ifdef ATAFB_FALCON
116 struct falcon_hw {
117 /* Here are fields for storing a video mode, as direct
118 * parameters for the hardware.
119 */
120 short sync;
121 short line_width;
122 short line_offset;
123 short st_shift;
124 short f_shift;
125 short vid_control;
126 short vid_mode;
127 short xoffset;
128 short hht, hbb, hbe, hdb, hde, hss;
129 short vft, vbb, vbe, vdb, vde, vss;
130 /* auxiliary information */
131 short mono;
132 short ste_mode;
133 short bpp;
134 } falcon;
135 #endif
136 /* Nothing needed for external mode */
137 } hw;
138 } current_par;
139
140 /* Don't calculate an own resolution, and thus don't change the one found when
141 * booting (currently used for the Falcon to keep settings for internal video
142 * hardware extensions (e.g. ScreenBlaster) */
143 static int DontCalcRes = 0;
144
145 #ifdef ATAFB_FALCON
146 #define HHT hw.falcon.hht
147 #define HBB hw.falcon.hbb
148 #define HBE hw.falcon.hbe
149 #define HDB hw.falcon.hdb
150 #define HDE hw.falcon.hde
151 #define HSS hw.falcon.hss
152 #define VFT hw.falcon.vft
153 #define VBB hw.falcon.vbb
154 #define VBE hw.falcon.vbe
155 #define VDB hw.falcon.vdb
156 #define VDE hw.falcon.vde
157 #define VSS hw.falcon.vss
158 #define VCO_CLOCK25 0x04
159 #define VCO_CSYPOS 0x10
160 #define VCO_VSYPOS 0x20
161 #define VCO_HSYPOS 0x40
162 #define VCO_SHORTOFFS 0x100
163 #define VMO_DOUBLE 0x01
164 #define VMO_INTER 0x02
165 #define VMO_PREMASK 0x0c
166 #endif
167
168 static struct fb_info fb_info;
169
170 static void *screen_base; /* base address of screen */
171 static void *real_screen_base; /* (only for Overscan) */
172
173 static int screen_len;
174
175 static int current_par_valid=0;
176
177 static int mono_moni=0;
178
179 static struct display disp;
180
181
182 #ifdef ATAFB_EXT
183 /* external video handling */
184
185 static unsigned external_xres;
186 static unsigned external_xres_virtual;
187 static unsigned external_yres;
188 /* not needed - atafb will never support panning/hardwarescroll with external
189 * static unsigned external_yres_virtual;
190 */
191
192 static unsigned external_depth;
193 static int external_pmode;
194 static void *external_addr = 0;
195 static unsigned long external_len;
196 static unsigned long external_vgaiobase = 0;
197 static unsigned int external_bitspercol = 6;
198
199 /*
200 JOE <joe@amber.dinoco.de>:
201 added card type for external driver, is only needed for
202 colormap handling.
203 */
204
205 enum cardtype { IS_VGA, IS_MV300 };
206 static enum cardtype external_card_type = IS_VGA;
207
208 /*
209 The MV300 mixes the color registers. So we need an array of munged
210 indices in order to access the correct reg.
211 */
212 static int MV300_reg_1bit[2]={0,1};
213 static int MV300_reg_4bit[16]={
214 0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15 };
215 static int MV300_reg_8bit[256]={
216 0, 128, 64, 192, 32, 160, 96, 224, 16, 144, 80, 208, 48, 176, 112, 240,
217 8, 136, 72, 200, 40, 168, 104, 232, 24, 152, 88, 216, 56, 184, 120, 248,
218 4, 132, 68, 196, 36, 164, 100, 228, 20, 148, 84, 212, 52, 180, 116, 244,
219 12, 140, 76, 204, 44, 172, 108, 236, 28, 156, 92, 220, 60, 188, 124, 252,
220 2, 130, 66, 194, 34, 162, 98, 226, 18, 146, 82, 210, 50, 178, 114, 242,
221 10, 138, 74, 202, 42, 170, 106, 234, 26, 154, 90, 218, 58, 186, 122, 250,
222 6, 134, 70, 198, 38, 166, 102, 230, 22, 150, 86, 214, 54, 182, 118, 246,
223 14, 142, 78, 206, 46, 174, 110, 238, 30, 158, 94, 222, 62, 190, 126, 254,
224 1, 129, 65, 193, 33, 161, 97, 225, 17, 145, 81, 209, 49, 177, 113, 241,
225 9, 137, 73, 201, 41, 169, 105, 233, 25, 153, 89, 217, 57, 185, 121, 249,
226 5, 133, 69, 197, 37, 165, 101, 229, 21, 149, 85, 213, 53, 181, 117, 245,
227 13, 141, 77, 205, 45, 173, 109, 237, 29, 157, 93, 221, 61, 189, 125, 253,
228 3, 131, 67, 195, 35, 163, 99, 227, 19, 147, 83, 211, 51, 179, 115, 243,
229 11, 139, 75, 203, 43, 171, 107, 235, 27, 155, 91, 219, 59, 187, 123, 251,
230 7, 135, 71, 199, 39, 167, 103, 231, 23, 151, 87, 215, 55, 183, 119, 247,
231 15, 143, 79, 207, 47, 175, 111, 239, 31, 159, 95, 223, 63, 191, 127, 255 };
232
233 static int *MV300_reg = MV300_reg_8bit;
234
235 /*
236 And on the MV300 it's difficult to read out the hardware palette. So we
237 just keep track of the set colors in our own array here, and use that!
238 */
239
240 static struct { unsigned char red,green,blue,pad; } ext_color[256];
241 #endif /* ATAFB_EXT */
242
243
244 static int inverse=0;
245
246 extern int fontheight_8x8;
247 extern int fontwidth_8x8;
248 extern unsigned char fontdata_8x8[];
249
250 extern int fontheight_8x16;
251 extern int fontwidth_8x16;
252 extern unsigned char fontdata_8x16[];
253
254 /* ++roman: This structure abstracts from the underlying hardware (ST(e),
255 * TT, or Falcon.
256 *
257 * int (*detect)( void )
258 * This function should detect the current video mode settings and
259 * store them in atafb_predefined[0] for later reference by the
260 * user. Return the index+1 of an equivalent predefined mode or 0
261 * if there is no such.
262 *
263 * int (*encode_fix)( struct fb_fix_screeninfo *fix,
264 * struct atafb_par *par )
265 * This function should fill in the 'fix' structure based on the
266 * values in the 'par' structure.
267 *
268 * int (*decode_var)( struct fb_var_screeninfo *var,
269 * struct atafb_par *par )
270 * Get the video params out of 'var'. If a value doesn't fit, round
271 * it up, if it's too big, return EINVAL.
272 * Round up in the following order: bits_per_pixel, xres, yres,
273 * xres_virtual, yres_virtual, xoffset, yoffset, grayscale, bitfields,
274 * horizontal timing, vertical timing.
275 *
276 * int (*encode_var)( struct fb_var_screeninfo *var,
277 * struct atafb_par *par );
278 * Fill the 'var' structure based on the values in 'par' and maybe
279 * other values read out of the hardware.
280 *
281 * void (*get_par)( struct atafb_par *par )
282 * Fill the hardware's 'par' structure.
283 *
284 * void (*set_par)( struct atafb_par *par )
285 * Set the hardware according to 'par'.
286 *
287 * int (*getcolreg)( unsigned regno, unsigned *red,
288 * unsigned *green, unsigned *blue,
289 * unsigned *transp, struct fb_info *info )
290 * Read a single color register and split it into
291 * colors/transparent. Return != 0 for invalid regno.
292 *
293 * void (*set_screen_base)(void *s_base)
294 * Set the base address of the displayed frame buffer. Only called
295 * if yres_virtual > yres or xres_virtual > xres.
296 *
297 * int (*blank)( int blank_mode )
298 * Blank the screen if blank_mode!=0, else unblank. If blank==NULL then
299 * the caller blanks by setting the CLUT to all black. Return 0 if blanking
300 * succeeded, !=0 if un-/blanking failed due to e.g. a video mode which
301 * doesn't support it. Implements VESA suspend and powerdown modes on
302 * hardware that supports disabling hsync/vsync:
303 * blank_mode==2: suspend vsync, 3:suspend hsync, 4: powerdown.
304 */
305
306 static struct fb_hwswitch {
307 int (*detect)( void );
308 int (*encode_fix)( struct fb_fix_screeninfo *fix,
309 struct atafb_par *par );
310 int (*decode_var)( struct fb_var_screeninfo *var,
311 struct atafb_par *par );
312 int (*encode_var)( struct fb_var_screeninfo *var,
313 struct atafb_par *par );
314 void (*get_par)( struct atafb_par *par );
315 void (*set_par)( struct atafb_par *par );
316 int (*getcolreg)( unsigned regno, unsigned *red,
317 unsigned *green, unsigned *blue,
318 unsigned *transp, struct fb_info *info );
319 void (*set_screen_base)(void *s_base);
320 int (*blank)( int blank_mode );
321 int (*pan_display)( struct fb_var_screeninfo *var,
322 struct atafb_par *par);
323 } *fbhw;
324
325 static char *autodetect_names[] = {"autodetect", NULL};
326 static char *stlow_names[] = {"stlow", NULL};
327 static char *stmid_names[] = {"stmid", "default5", NULL};
328 static char *sthigh_names[] = {"sthigh", "default4", NULL};
329 static char *ttlow_names[] = {"ttlow", NULL};
330 static char *ttmid_names[]= {"ttmid", "default1", NULL};
331 static char *tthigh_names[]= {"tthigh", "default2", NULL};
332 static char *vga2_names[] = {"vga2", NULL};
333 static char *vga4_names[] = {"vga4", NULL};
334 static char *vga16_names[] = {"vga16", "default3", NULL};
335 static char *vga256_names[] = {"vga256", NULL};
336 static char *falh2_names[] = {"falh2", NULL};
337 static char *falh16_names[] = {"falh16", NULL};
338
339 static char **fb_var_names[] = {
340 /* Writing the name arrays directly in this array (via "(char *[]){...}")
341 * crashes gcc 2.5.8 (sigsegv) if the inner array
342 * contains more than two items. I've also seen that all elements
343 * were identical to the last (my cross-gcc) :-(*/
344 autodetect_names,
345 stlow_names,
346 stmid_names,
347 sthigh_names,
348 ttlow_names,
349 ttmid_names,
350 tthigh_names,
351 vga2_names,
352 vga4_names,
353 vga16_names,
354 vga256_names,
355 falh2_names,
356 falh16_names,
357 NULL
358 /* ,NULL */ /* this causes a sigsegv on my gcc-2.5.8 */
359 };
360
361 static struct fb_var_screeninfo atafb_predefined[] = {
362 /*
363 * yres_virtual==0 means use hw-scrolling if possible, else yres
364 */
365 { /* autodetect */
366 0, 0, 0, 0, 0, 0, 0, 0, /* xres-grayscale */
367 {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, /* red green blue tran*/
368 0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0 },
369 { /* st low */
370 320, 200, 320, 0, 0, 0, 4, 0,
371 {0, 4, 0}, {0, 4, 0}, {0, 4, 0}, {0, 0, 0},
372 0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0 },
373 { /* st mid */
374 640, 200, 640, 0, 0, 0, 2, 0,
375 {0, 4, 0}, {0, 4, 0}, {0, 4, 0}, {0, 0, 0},
376 0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0 },
377 { /* st high */
378 640, 400, 640, 0, 0, 0, 1, 0,
379 {0, 4, 0}, {0, 4, 0}, {0, 4, 0}, {0, 0, 0},
380 0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0 },
381 { /* tt low */
382 320, 480, 320, 0, 0, 0, 8, 0,
383 {0, 4, 0}, {0, 4, 0}, {0, 4, 0}, {0, 0, 0},
384 0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0 },
385 { /* tt mid */
386 640, 480, 640, 0, 0, 0, 4, 0,
387 {0, 4, 0}, {0, 4, 0}, {0, 4, 0}, {0, 0, 0},
388 0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0 },
389 { /* tt high */
390 1280, 960, 1280, 0, 0, 0, 1, 0,
391 {0, 4, 0}, {0, 4, 0}, {0, 4, 0}, {0, 0, 0},
392 0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0 },
393 { /* vga2 */
394 640, 480, 640, 0, 0, 0, 1, 0,
395 {0, 6, 0}, {0, 6, 0}, {0, 6, 0}, {0, 0, 0},
396 0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0 },
397 { /* vga4 */
398 640, 480, 640, 0, 0, 0, 2, 0,
399 {0, 4, 0}, {0, 4, 0}, {0, 4, 0}, {0, 0, 0},
400 0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0 },
401 { /* vga16 */
402 640, 480, 640, 0, 0, 0, 4, 0,
403 {0, 6, 0}, {0, 6, 0}, {0, 6, 0}, {0, 0, 0},
404 0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0 },
405 { /* vga256 */
406 640, 480, 640, 0, 0, 0, 8, 0,
407 {0, 6, 0}, {0, 6, 0}, {0, 6, 0}, {0, 0, 0},
408 0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0 },
409 { /* falh2 */
410 896, 608, 896, 0, 0, 0, 1, 0,
411 {0, 6, 0}, {0, 6, 0}, {0, 6, 0}, {0, 0, 0},
412 0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0 },
413 { /* falh16 */
414 896, 608, 896, 0, 0, 0, 4, 0,
415 {0, 6, 0}, {0, 6, 0}, {0, 6, 0}, {0, 0, 0},
416 0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0 },
417 };
418
419 static int num_atafb_predefined=ARRAY_SIZE(atafb_predefined);
420
421
422 static int
423 get_video_mode(char *vname)
424 {
425 char ***name_list;
426 char **name;
427 int i;
428 name_list=fb_var_names;
429 for (i = 0 ; i < num_atafb_predefined ; i++) {
430 name=*(name_list++);
431 if (! name || ! *name)
432 break;
433 while (*name) {
434 if (! strcmp(vname, *name))
435 return i+1;
436 name++;
437 }
438 }
439 return 0;
440 }
441
442
443
444 /* ------------------- TT specific functions ---------------------- */
445
446 #ifdef ATAFB_TT
447
448 static int tt_encode_fix( struct fb_fix_screeninfo *fix,
449 struct atafb_par *par )
450
451 {
452 int mode;
453
454 strcpy(fix->id,"Atari Builtin");
455 fix->smem_start = (unsigned long)real_screen_base;
456 fix->smem_len = screen_len;
457 fix->type=FB_TYPE_INTERLEAVED_PLANES;
458 fix->type_aux=2;
459 fix->visual=FB_VISUAL_PSEUDOCOLOR;
460 mode = par->hw.tt.mode & TT_SHIFTER_MODEMASK;
461 if (mode == TT_SHIFTER_TTHIGH || mode == TT_SHIFTER_STHIGH) {
462 fix->type=FB_TYPE_PACKED_PIXELS;
463 fix->type_aux=0;
464 if (mode == TT_SHIFTER_TTHIGH)
465 fix->visual=FB_VISUAL_MONO01;
466 }
467 fix->xpanstep=0;
468 fix->ypanstep=1;
469 fix->ywrapstep=0;
470 fix->line_length = 0;
471 fix->accel = FB_ACCEL_ATARIBLITT;
472 return 0;
473 }
474
475
476 static int tt_decode_var( struct fb_var_screeninfo *var,
477 struct atafb_par *par )
478 {
479 int xres=var->xres;
480 int yres=var->yres;
481 int bpp=var->bits_per_pixel;
482 int linelen;
483 int yres_virtual = var->yres_virtual;
484
485 if (mono_moni) {
486 if (bpp > 1 || xres > sttt_xres*2 || yres >tt_yres*2)
487 return -EINVAL;
488 par->hw.tt.mode=TT_SHIFTER_TTHIGH;
489 xres=sttt_xres*2;
490 yres=tt_yres*2;
491 bpp=1;
492 } else {
493 if (bpp > 8 || xres > sttt_xres || yres > tt_yres)
494 return -EINVAL;
495 if (bpp > 4) {
496 if (xres > sttt_xres/2 || yres > tt_yres)
497 return -EINVAL;
498 par->hw.tt.mode=TT_SHIFTER_TTLOW;
499 xres=sttt_xres/2;
500 yres=tt_yres;
501 bpp=8;
502 }
503 else if (bpp > 2) {
504 if (xres > sttt_xres || yres > tt_yres)
505 return -EINVAL;
506 if (xres > sttt_xres/2 || yres > st_yres/2) {
507 par->hw.tt.mode=TT_SHIFTER_TTMID;
508 xres=sttt_xres;
509 yres=tt_yres;
510 bpp=4;
511 }
512 else {
513 par->hw.tt.mode=TT_SHIFTER_STLOW;
514 xres=sttt_xres/2;
515 yres=st_yres/2;
516 bpp=4;
517 }
518 }
519 else if (bpp > 1) {
520 if (xres > sttt_xres || yres > st_yres/2)
521 return -EINVAL;
522 par->hw.tt.mode=TT_SHIFTER_STMID;
523 xres=sttt_xres;
524 yres=st_yres/2;
525 bpp=2;
526 }
527 else if (var->xres > sttt_xres || var->yres > st_yres) {
528 return -EINVAL;
529 }
530 else {
531 par->hw.tt.mode=TT_SHIFTER_STHIGH;
532 xres=sttt_xres;
533 yres=st_yres;
534 bpp=1;
535 }
536 }
537 if (yres_virtual <= 0)
538 yres_virtual = 0;
539 else if (yres_virtual < yres)
540 yres_virtual = yres;
541 if (var->sync & FB_SYNC_EXT)
542 par->hw.tt.sync=0;
543 else
544 par->hw.tt.sync=1;
545 linelen=xres*bpp/8;
546 if (yres_virtual * linelen > screen_len && screen_len)
547 return -EINVAL;
548 if (yres * linelen > screen_len && screen_len)
549 return -EINVAL;
550 if (var->yoffset + yres > yres_virtual && yres_virtual)
551 return -EINVAL;
552 par->yres_virtual = yres_virtual;
553 par->screen_base = screen_base + var->yoffset * linelen;
554 return 0;
555 }
556
557 static int tt_encode_var( struct fb_var_screeninfo *var,
558 struct atafb_par *par )
559 {
560 int linelen;
561 memset(var, 0, sizeof(struct fb_var_screeninfo));
562 var->red.offset=0;
563 var->red.length=4;
564 var->red.msb_right=0;
565 var->grayscale=0;
566
567 var->pixclock=31041;
568 var->left_margin=120; /* these may be incorrect */
569 var->right_margin=100;
570 var->upper_margin=8;
571 var->lower_margin=16;
572 var->hsync_len=140;
573 var->vsync_len=30;
574
575 var->height=-1;
576 var->width=-1;
577
578 if (par->hw.tt.sync & 1)
579 var->sync=0;
580 else
581 var->sync=FB_SYNC_EXT;
582
583 switch (par->hw.tt.mode & TT_SHIFTER_MODEMASK) {
584 case TT_SHIFTER_STLOW:
585 var->xres=sttt_xres/2;
586 var->xres_virtual=sttt_xres_virtual/2;
587 var->yres=st_yres/2;
588 var->bits_per_pixel=4;
589 break;
590 case TT_SHIFTER_STMID:
591 var->xres=sttt_xres;
592 var->xres_virtual=sttt_xres_virtual;
593 var->yres=st_yres/2;
594 var->bits_per_pixel=2;
595 break;
596 case TT_SHIFTER_STHIGH:
597 var->xres=sttt_xres;
598 var->xres_virtual=sttt_xres_virtual;
599 var->yres=st_yres;
600 var->bits_per_pixel=1;
601 break;
602 case TT_SHIFTER_TTLOW:
603 var->xres=sttt_xres/2;
604 var->xres_virtual=sttt_xres_virtual/2;
605 var->yres=tt_yres;
606 var->bits_per_pixel=8;
607 break;
608 case TT_SHIFTER_TTMID:
609 var->xres=sttt_xres;
610 var->xres_virtual=sttt_xres_virtual;
611 var->yres=tt_yres;
612 var->bits_per_pixel=4;
613 break;
614 case TT_SHIFTER_TTHIGH:
615 var->red.length=0;
616 var->xres=sttt_xres*2;
617 var->xres_virtual=sttt_xres_virtual*2;
618 var->yres=tt_yres*2;
619 var->bits_per_pixel=1;
620 break;
621 }
622 var->blue=var->green=var->red;
623 var->transp.offset=0;
624 var->transp.length=0;
625 var->transp.msb_right=0;
626 linelen=var->xres_virtual * var->bits_per_pixel / 8;
627 if (! use_hwscroll)
628 var->yres_virtual=var->yres;
629 else if (screen_len) {
630 if (par->yres_virtual)
631 var->yres_virtual = par->yres_virtual;
632 else
633 /* yres_virtual==0 means use maximum */
634 var->yres_virtual = screen_len / linelen;
635 } else {
636 if (hwscroll < 0)
637 var->yres_virtual = 2 * var->yres;
638 else
639 var->yres_virtual=var->yres+hwscroll * 16;
640 }
641 var->xoffset=0;
642 if (screen_base)
643 var->yoffset=(par->screen_base - screen_base)/linelen;
644 else
645 var->yoffset=0;
646 var->nonstd=0;
647 var->activate=0;
648 var->vmode=FB_VMODE_NONINTERLACED;
649 return 0;
650 }
651
652
653 static void tt_get_par( struct atafb_par *par )
654 {
655 unsigned long addr;
656 par->hw.tt.mode=shifter_tt.tt_shiftmode;
657 par->hw.tt.sync=shifter.syncmode;
658 addr = ((shifter.bas_hi & 0xff) << 16) |
659 ((shifter.bas_md & 0xff) << 8) |
660 ((shifter.bas_lo & 0xff));
661 par->screen_base = phys_to_virt(addr);
662 }
663
664 static void tt_set_par( struct atafb_par *par )
665 {
666 shifter_tt.tt_shiftmode=par->hw.tt.mode;
667 shifter.syncmode=par->hw.tt.sync;
668 /* only set screen_base if really necessary */
669 if (current_par.screen_base != par->screen_base)
670 fbhw->set_screen_base(par->screen_base);
671 }
672
673
674 static int tt_getcolreg(unsigned regno, unsigned *red,
675 unsigned *green, unsigned *blue,
676 unsigned *transp, struct fb_info *info)
677 {
678 int t, col;
679
680 if ((shifter_tt.tt_shiftmode & TT_SHIFTER_MODEMASK) == TT_SHIFTER_STHIGH)
681 regno += 254;
682 if (regno > 255)
683 return 1;
684 t = tt_palette[regno];
685 col = t & 15;
686 col |= col << 4;
687 col |= col << 8;
688 *blue = col;
689 col = (t >> 4) & 15;
690 col |= col << 4;
691 col |= col << 8;
692 *green = col;
693 col = (t >> 8) & 15;
694 col |= col << 4;
695 col |= col << 8;
696 *red = col;
697 *transp = 0;
698 return 0;
699 }
700
701
702 static int tt_setcolreg(unsigned regno, unsigned red,
703 unsigned green, unsigned blue,
704 unsigned transp, struct fb_info *info)
705 {
706 if ((shifter_tt.tt_shiftmode & TT_SHIFTER_MODEMASK) == TT_SHIFTER_STHIGH)
707 regno += 254;
708 if (regno > 255)
709 return 1;
710 tt_palette[regno] = (((red >> 12) << 8) | ((green >> 12) << 4) |
711 (blue >> 12));
712 if ((shifter_tt.tt_shiftmode & TT_SHIFTER_MODEMASK) ==
713 TT_SHIFTER_STHIGH && regno == 254)
714 tt_palette[0] = 0;
715 return 0;
716 }
717
718
719 static int tt_detect( void )
720
721 { struct atafb_par par;
722
723 /* Determine the connected monitor: The DMA sound must be
724 * disabled before reading the MFP GPIP, because the Sound
725 * Done Signal and the Monochrome Detect are XORed together!
726 *
727 * Even on a TT, we should look if there is a DMA sound. It was
728 * announced that the Eagle is TT compatible, but only the PCM is
729 * missing...
730 */
731 if (ATARIHW_PRESENT(PCM_8BIT)) {
732 tt_dmasnd.ctrl = DMASND_CTRL_OFF;
733 udelay(20); /* wait a while for things to settle down */
734 }
735 mono_moni = (mfp.par_dt_reg & 0x80) == 0;
736
737 tt_get_par(&par);
738 tt_encode_var(&atafb_predefined[0], &par);
739
740 return 1;
741 }
742
743 #endif /* ATAFB_TT */
744
745 /* ------------------- Falcon specific functions ---------------------- */
746
747 #ifdef ATAFB_FALCON
748
749 static int mon_type; /* Falcon connected monitor */
750 static int f030_bus_width; /* Falcon ram bus width (for vid_control) */
751 #define F_MON_SM 0
752 #define F_MON_SC 1
753 #define F_MON_VGA 2
754 #define F_MON_TV 3
755
756 static struct pixel_clock {
757 unsigned long f; /* f/[Hz] */
758 unsigned long t; /* t/[ps] (=1/f) */
759 int right, hsync, left; /* standard timing in clock cycles, not pixel */
760 /* hsync initialized in falcon_detect() */
761 int sync_mask; /* or-mask for hw.falcon.sync to set this clock */
762 int control_mask; /* ditto, for hw.falcon.vid_control */
763 }
764 f25 = {25175000, 39721, 18, 0, 42, 0x0, VCO_CLOCK25},
765 f32 = {32000000, 31250, 18, 0, 42, 0x0, 0},
766 fext = { 0, 0, 18, 0, 42, 0x1, 0};
767
768 /* VIDEL-prescale values [mon_type][pixel_length from VCO] */
769 static int vdl_prescale[4][3] = {{4,2,1}, {4,2,1}, {4,2,2}, {4,2,1}};
770
771 /* Default hsync timing [mon_type] in picoseconds */
772 static long h_syncs[4] = {3000000, 4875000, 4000000, 4875000};
773
774 #ifdef FBCON_HAS_CFB16
775 static u16 fbcon_cfb16_cmap[16];
776 #endif
777
778 static inline int hxx_prescale(struct falcon_hw *hw)
779 {
780 return hw->ste_mode ? 16 :
781 vdl_prescale[mon_type][hw->vid_mode >> 2 & 0x3];
782 }
783
784 static int falcon_encode_fix( struct fb_fix_screeninfo *fix,
785 struct atafb_par *par )
786 {
787 strcpy(fix->id, "Atari Builtin");
788 fix->smem_start = (unsigned long)real_screen_base;
789 fix->smem_len = screen_len;
790 fix->type = FB_TYPE_INTERLEAVED_PLANES;
791 fix->type_aux = 2;
792 fix->visual = FB_VISUAL_PSEUDOCOLOR;
793 fix->xpanstep = 1;
794 fix->ypanstep = 1;
795 fix->ywrapstep = 0;
796 if (par->hw.falcon.mono) {
797 fix->type = FB_TYPE_PACKED_PIXELS;
798 fix->type_aux = 0;
799 /* no smooth scrolling with longword aligned video mem */
800 fix->xpanstep = 32;
801 }
802 else if (par->hw.falcon.f_shift & 0x100) {
803 fix->type = FB_TYPE_PACKED_PIXELS;
804 fix->type_aux = 0;
805 /* Is this ok or should it be DIRECTCOLOR? */
806 fix->visual = FB_VISUAL_TRUECOLOR;
807 fix->xpanstep = 2;
808 }
809 fix->line_length = 0;
810 fix->accel = FB_ACCEL_ATARIBLITT;
811 return 0;
812 }
813
814
815 static int falcon_decode_var( struct fb_var_screeninfo *var,
816 struct atafb_par *par )
817 {
818 int bpp = var->bits_per_pixel;
819 int xres = var->xres;
820 int yres = var->yres;
821 int xres_virtual = var->xres_virtual;
822 int yres_virtual = var->yres_virtual;
823 int left_margin, right_margin, hsync_len;
824 int upper_margin, lower_margin, vsync_len;
825 int linelen;
826 int interlace = 0, doubleline = 0;
827 struct pixel_clock *pclock;
828 int plen; /* width of pixel in clock cycles */
829 int xstretch;
830 int prescale;
831 int longoffset = 0;
832 int hfreq, vfreq;
833
834 /*
835 Get the video params out of 'var'. If a value doesn't fit, round
836 it up, if it's too big, return EINVAL.
837 Round up in the following order: bits_per_pixel, xres, yres,
838 xres_virtual, yres_virtual, xoffset, yoffset, grayscale, bitfields,
839 horizontal timing, vertical timing.
840
841 There is a maximum of screen resolution determined by pixelclock
842 and minimum frame rate -- (X+hmarg.)*(Y+vmarg.)*vfmin <= pixelclock.
843 In interlace mode this is " * " *vfmin <= pixelclock.
844 Additional constraints: hfreq.
845 Frequency range for multisync monitors is given via command line.
846 For TV and SM124 both frequencies are fixed.
847
848 X % 16 == 0 to fit 8x?? font (except 1 bitplane modes must use X%32==0)
849 Y % 16 == 0 to fit 8x16 font
850 Y % 8 == 0 if Y<400
851
852 Currently interlace and doubleline mode in var are ignored.
853 On SM124 and TV only the standard resolutions can be used.
854 */
855
856 /* Reject uninitialized mode */
857 if (!xres || !yres || !bpp)
858 return -EINVAL;
859
860 if (mon_type == F_MON_SM && bpp != 1) {
861 return -EINVAL;
862 }
863 else if (bpp <= 1) {
864 bpp = 1;
865 par->hw.falcon.f_shift = 0x400;
866 par->hw.falcon.st_shift = 0x200;
867 }
868 else if (bpp <= 2) {
869 bpp = 2;
870 par->hw.falcon.f_shift = 0x000;
871 par->hw.falcon.st_shift = 0x100;
872 }
873 else if (bpp <= 4) {
874 bpp = 4;
875 par->hw.falcon.f_shift = 0x000;
876 par->hw.falcon.st_shift = 0x000;
877 }
878 else if (bpp <= 8) {
879 bpp = 8;
880 par->hw.falcon.f_shift = 0x010;
881 }
882 else if (bpp <= 16) {
883 bpp = 16; /* packed pixel mode */
884 par->hw.falcon.f_shift = 0x100; /* hicolor, no overlay */
885 }
886 else
887 return -EINVAL;
888 par->hw.falcon.bpp = bpp;
889
890 if (mon_type == F_MON_SM || DontCalcRes) {
891 /* Skip all calculations. VGA/TV/SC1224 only supported. */
892 struct fb_var_screeninfo *myvar = &atafb_predefined[0];
893
894 if (bpp > myvar->bits_per_pixel ||
895 var->xres > myvar->xres ||
896 var->yres > myvar->yres)
897 return -EINVAL;
898 fbhw->get_par(par); /* Current par will be new par */
899 goto set_screen_base; /* Don't forget this */
900 }
901
902 /* Only some fixed resolutions < 640x400 */
903 if (xres <= 320)
904 xres = 320;
905 else if (xres <= 640 && bpp != 16)
906 xres = 640;
907 if (yres <= 200)
908 yres = 200;
909 else if (yres <= 240)
910 yres = 240;
911 else if (yres <= 400)
912 yres = 400;
913
914 /* 2 planes must use STE compatibility mode */
915 par->hw.falcon.ste_mode = bpp==2;
916 par->hw.falcon.mono = bpp==1;
917
918 /* Total and visible scanline length must be a multiple of one longword,
919 * this and the console fontwidth yields the alignment for xres and
920 * xres_virtual.
921 * TODO: this way "odd" fontheights are not supported
922 *
923 * Special case in STE mode: blank and graphic positions don't align,
924 * avoid trash at right margin
925 */
926 if (par->hw.falcon.ste_mode)
927 xres = (xres + 63) & ~63;
928 else if (bpp == 1)
929 xres = (xres + 31) & ~31;
930 else
931 xres = (xres + 15) & ~15;
932 if (yres >= 400)
933 yres = (yres + 15) & ~15;
934 else
935 yres = (yres + 7) & ~7;
936
937 if (xres_virtual < xres)
938 xres_virtual = xres;
939 else if (bpp == 1)
940 xres_virtual = (xres_virtual + 31) & ~31;
941 else
942 xres_virtual = (xres_virtual + 15) & ~15;
943
944 if (yres_virtual <= 0)
945 yres_virtual = 0;
946 else if (yres_virtual < yres)
947 yres_virtual = yres;
948
949 /* backward bug-compatibility */
950 if (var->pixclock > 1)
951 var->pixclock -= 1;
952
953 par->hw.falcon.line_width = bpp * xres / 16;
954 par->hw.falcon.line_offset = bpp * (xres_virtual - xres) / 16;
955
956 /* single or double pixel width */
957 xstretch = (xres < 640) ? 2 : 1;
958
959 #if 0 /* SM124 supports only 640x400, this is rejected above */
960 if (mon_type == F_MON_SM) {
961 if (xres != 640 && yres != 400)
962 return -EINVAL;
963 plen = 1;
964 pclock = &f32;
965 /* SM124-mode is special */
966 par->hw.falcon.ste_mode = 1;
967 par->hw.falcon.f_shift = 0x000;
968 par->hw.falcon.st_shift = 0x200;
969 left_margin = hsync_len = 128 / plen;
970 right_margin = 0;
971 /* TODO set all margins */
972 }
973 else
974 #endif
975 if (mon_type == F_MON_SC || mon_type == F_MON_TV) {
976 plen = 2 * xstretch;
977 if (var->pixclock > f32.t * plen)
978 return -EINVAL;
979 pclock = &f32;
980 if (yres > 240)
981 interlace = 1;
982 if (var->pixclock == 0) {
983 /* set some minimal margins which center the screen */
984 left_margin = 32;
985 right_margin = 18;
986 hsync_len = pclock->hsync / plen;
987 upper_margin = 31;
988 lower_margin = 14;
989 vsync_len = interlace ? 3 : 4;
990 } else {
991 left_margin = var->left_margin;
992 right_margin = var->right_margin;
993 hsync_len = var->hsync_len;
994 upper_margin = var->upper_margin;
995 lower_margin = var->lower_margin;
996 vsync_len = var->vsync_len;
997 if (var->vmode & FB_VMODE_INTERLACED) {
998 upper_margin = (upper_margin + 1) / 2;
999 lower_margin = (lower_margin + 1) / 2;
1000 vsync_len = (vsync_len + 1) / 2;
1001 } else if (var->vmode & FB_VMODE_DOUBLE) {
1002 upper_margin *= 2;
1003 lower_margin *= 2;
1004 vsync_len *= 2;
1005 }
1006 }
1007 }
1008 else
1009 { /* F_MON_VGA */
1010 if (bpp == 16)
1011 xstretch = 2; /* Double pixel width only for hicolor */
1012 /* Default values are used for vert./hor. timing if no pixelclock given. */
1013 if (var->pixclock == 0) {
1014 int linesize;
1015
1016 /* Choose master pixelclock depending on hor. timing */
1017 plen = 1 * xstretch;
1018 if ((plen * xres + f25.right+f25.hsync+f25.left) *
1019 fb_info.monspecs.hfmin < f25.f)
1020 pclock = &f25;
1021 else if ((plen * xres + f32.right+f32.hsync+f32.left) *
1022 fb_info.monspecs.hfmin < f32.f)
1023 pclock = &f32;
1024 else if ((plen * xres + fext.right+fext.hsync+fext.left) *
1025 fb_info.monspecs.hfmin < fext.f
1026 && fext.f)
1027 pclock = &fext;
1028 else
1029 return -EINVAL;
1030
1031 left_margin = pclock->left / plen;
1032 right_margin = pclock->right / plen;
1033 hsync_len = pclock->hsync / plen;
1034 linesize = left_margin + xres + right_margin + hsync_len;
1035 upper_margin = 31;
1036 lower_margin = 11;
1037 vsync_len = 3;
1038 }
1039 else {
1040 /* Choose largest pixelclock <= wanted clock */
1041 int i;
1042 unsigned long pcl = ULONG_MAX;
1043 pclock = 0;
1044 for (i=1; i <= 4; i *= 2) {
1045 if (f25.t*i >= var->pixclock && f25.t*i < pcl) {
1046 pcl = f25.t * i;
1047 pclock = &f25;
1048 }
1049 if (f32.t*i >= var->pixclock && f32.t*i < pcl) {
1050 pcl = f32.t * i;
1051 pclock = &f32;
1052 }
1053 if (fext.t && fext.t*i >= var->pixclock && fext.t*i < pcl) {
1054 pcl = fext.t * i;
1055 pclock = &fext;
1056 }
1057 }
1058 if (!pclock)
1059 return -EINVAL;
1060 plen = pcl / pclock->t;
1061
1062 left_margin = var->left_margin;
1063 right_margin = var->right_margin;
1064 hsync_len = var->hsync_len;
1065 upper_margin = var->upper_margin;
1066 lower_margin = var->lower_margin;
1067 vsync_len = var->vsync_len;
1068 /* Internal unit is [single lines per (half-)frame] */
1069 if (var->vmode & FB_VMODE_INTERLACED) {
1070 /* # lines in half frame */
1071 /* External unit is [lines per full frame] */
1072 upper_margin = (upper_margin + 1) / 2;
1073 lower_margin = (lower_margin + 1) / 2;
1074 vsync_len = (vsync_len + 1) / 2;
1075 }
1076 else if (var->vmode & FB_VMODE_DOUBLE) {
1077 /* External unit is [double lines per frame] */
1078 upper_margin *= 2;
1079 lower_margin *= 2;
1080 vsync_len *= 2;
1081 }
1082 }
1083 if (pclock == &fext)
1084 longoffset = 1; /* VIDEL doesn't synchronize on short offset */
1085 }
1086 /* Is video bus bandwidth (32MB/s) too low for this resolution? */
1087 /* this is definitely wrong if bus clock != 32MHz */
1088 if (pclock->f / plen / 8 * bpp > 32000000L)
1089 return -EINVAL;
1090
1091 if (vsync_len < 1)
1092 vsync_len = 1;
1093
1094 /* include sync lengths in right/lower margin for all calculations */
1095 right_margin += hsync_len;
1096 lower_margin += vsync_len;
1097
1098 /* ! In all calculations of margins we use # of lines in half frame
1099 * (which is a full frame in non-interlace mode), so we can switch
1100 * between interlace and non-interlace without messing around
1101 * with these.
1102 */
1103 again:
1104 /* Set base_offset 128 and video bus width */
1105 par->hw.falcon.vid_control = mon_type | f030_bus_width;
1106 if (!longoffset)
1107 par->hw.falcon.vid_control |= VCO_SHORTOFFS; /* base_offset 64 */
1108 if (var->sync & FB_SYNC_HOR_HIGH_ACT)
1109 par->hw.falcon.vid_control |= VCO_HSYPOS;
1110 if (var->sync & FB_SYNC_VERT_HIGH_ACT)
1111 par->hw.falcon.vid_control |= VCO_VSYPOS;
1112 /* Pixelclock */
1113 par->hw.falcon.vid_control |= pclock->control_mask;
1114 /* External or internal clock */
1115 par->hw.falcon.sync = pclock->sync_mask | 0x2;
1116 /* Pixellength and prescale */
1117 par->hw.falcon.vid_mode = (2/plen) << 2;
1118 if (doubleline)
1119 par->hw.falcon.vid_mode |= VMO_DOUBLE;
1120 if (interlace)
1121 par->hw.falcon.vid_mode |= VMO_INTER;
1122
1123 /*********************
1124 Horizontal timing: unit = [master clock cycles]
1125 unit of hxx-registers: [master clock cycles * prescale]
1126 Hxx-registers are 9 bit wide
1127
1128 1 line = ((hht + 2) * 2 * prescale) clock cycles
1129
1130 graphic output = hdb & 0x200 ?
1131 ((hht+2)*2 - hdb + hde) * prescale - hdboff + hdeoff:
1132 ( hht + 2 - hdb + hde) * prescale - hdboff + hdeoff
1133 (this must be a multiple of plen*128/bpp, on VGA pixels
1134 to the right may be cut off with a bigger right margin)
1135
1136 start of graphics relative to start of 1st halfline = hdb & 0x200 ?
1137 (hdb - hht - 2) * prescale + hdboff :
1138 hdb * prescale + hdboff
1139
1140 end of graphics relative to start of 1st halfline =
1141 (hde + hht + 2) * prescale + hdeoff
1142 *********************/
1143 /* Calculate VIDEL registers */
1144 {
1145 int hdb_off, hde_off, base_off;
1146 int gstart, gend1, gend2, align;
1147
1148 prescale = hxx_prescale(&par->hw.falcon);
1149 base_off = par->hw.falcon.vid_control & VCO_SHORTOFFS ? 64 : 128;
1150
1151 /* Offsets depend on video mode */
1152 /* Offsets are in clock cycles, divide by prescale to
1153 * calculate hd[be]-registers
1154 */
1155 if (par->hw.falcon.f_shift & 0x100) {
1156 align = 1;
1157 hde_off = 0;
1158 hdb_off = (base_off + 16 * plen) + prescale;
1159 }
1160 else {
1161 align = 128 / bpp;
1162 hde_off = ((128 / bpp + 2) * plen);
1163 if (par->hw.falcon.ste_mode)
1164 hdb_off = (64 + base_off + (128 / bpp + 2) * plen) + prescale;
1165 else
1166 hdb_off = (base_off + (128 / bpp + 18) * plen) + prescale;
1167 }
1168
1169 gstart = (prescale/2 + plen * left_margin) / prescale;
1170 /* gend1 is for hde (gend-gstart multiple of align), shifter's xres */
1171 gend1 = gstart + ((xres + align-1) / align)*align * plen / prescale;
1172 /* gend2 is for hbb, visible xres (rest to gend1 is cut off by hblank) */
1173 gend2 = gstart + xres * plen / prescale;
1174 par->HHT = plen * (left_margin + xres + right_margin) /
1175 (2 * prescale) - 2;
1176 /* par->HHT = (gend2 + plen * right_margin / prescale) / 2 - 2;*/
1177
1178 par->HDB = gstart - hdb_off/prescale;
1179 par->HBE = gstart;
1180 if (par->HDB < 0) par->HDB += par->HHT + 2 + 0x200;
1181 par->HDE = gend1 - par->HHT - 2 - hde_off/prescale;
1182 par->HBB = gend2 - par->HHT - 2;
1183 #if 0
1184 /* One more Videl constraint: data fetch of two lines must not overlap */
1185 if ((par->HDB & 0x200) && (par->HDB & ~0x200) - par->HDE <= 5) {
1186 /* if this happens increase margins, decrease hfreq. */
1187 }
1188 #endif
1189 if (hde_off % prescale)
1190 par->HBB++; /* compensate for non matching hde and hbb */
1191 par->HSS = par->HHT + 2 - plen * hsync_len / prescale;
1192 if (par->HSS < par->HBB)
1193 par->HSS = par->HBB;
1194 }
1195
1196 /* check hor. frequency */
1197 hfreq = pclock->f / ((par->HHT+2)*prescale*2);
1198 if (hfreq > fb_info.monspecs.hfmax && mon_type!=F_MON_VGA) {
1199 /* ++guenther: ^^^^^^^^^^^^^^^^^^^ can't remember why I did this */
1200 /* Too high -> enlarge margin */
1201 left_margin += 1;
1202 right_margin += 1;
1203 goto again;
1204 }
1205 if (hfreq > fb_info.monspecs.hfmax || hfreq < fb_info.monspecs.hfmin)
1206 return -EINVAL;
1207
1208 /* Vxx-registers */
1209 /* All Vxx must be odd in non-interlace, since frame starts in the middle
1210 * of the first displayed line!
1211 * One frame consists of VFT+1 half lines. VFT+1 must be even in
1212 * non-interlace, odd in interlace mode for synchronisation.
1213 * Vxx-registers are 11 bit wide
1214 */
1215 par->VBE = (upper_margin * 2 + 1); /* must begin on odd halfline */
1216 par->VDB = par->VBE;
1217 par->VDE = yres;
1218 if (!interlace) par->VDE <<= 1;
1219 if (doubleline) par->VDE <<= 1; /* VDE now half lines per (half-)frame */
1220 par->VDE += par->VDB;
1221 par->VBB = par->VDE;
1222 par->VFT = par->VBB + (lower_margin * 2 - 1) - 1;
1223 par->VSS = par->VFT+1 - (vsync_len * 2 - 1);
1224 /* vbb,vss,vft must be even in interlace mode */
1225 if (interlace) {
1226 par->VBB++;
1227 par->VSS++;
1228 par->VFT++;
1229 }
1230
1231 /* V-frequency check, hope I didn't create any loop here. */
1232 /* Interlace and doubleline are mutually exclusive. */
1233 vfreq = (hfreq * 2) / (par->VFT + 1);
1234 if (vfreq > fb_info.monspecs.vfmax && !doubleline && !interlace) {
1235 /* Too high -> try again with doubleline */
1236 doubleline = 1;
1237 goto again;
1238 }
1239 else if (vfreq < fb_info.monspecs.vfmin && !interlace && !doubleline) {
1240 /* Too low -> try again with interlace */
1241 interlace = 1;
1242 goto again;
1243 }
1244 else if (vfreq < fb_info.monspecs.vfmin && doubleline) {
1245 /* Doubleline too low -> clear doubleline and enlarge margins */
1246 int lines;
1247 doubleline = 0;
1248 for (lines=0;
1249 (hfreq*2)/(par->VFT+1+4*lines-2*yres)>fb_info.monspecs.vfmax;
1250 lines++)
1251 ;
1252 upper_margin += lines;
1253 lower_margin += lines;
1254 goto again;
1255 }
1256 else if (vfreq > fb_info.monspecs.vfmax && doubleline) {
1257 /* Doubleline too high -> enlarge margins */
1258 int lines;
1259 for (lines=0;
1260 (hfreq*2)/(par->VFT+1+4*lines)>fb_info.monspecs.vfmax;
1261 lines+=2)
1262 ;
1263 upper_margin += lines;
1264 lower_margin += lines;
1265 goto again;
1266 }
1267 else if (vfreq > fb_info.monspecs.vfmax && interlace) {
1268 /* Interlace, too high -> enlarge margins */
1269 int lines;
1270 for (lines=0;
1271 (hfreq*2)/(par->VFT+1+4*lines)>fb_info.monspecs.vfmax;
1272 lines++)
1273 ;
1274 upper_margin += lines;
1275 lower_margin += lines;
1276 goto again;
1277 }
1278 else if (vfreq < fb_info.monspecs.vfmin ||
1279 vfreq > fb_info.monspecs.vfmax)
1280 return -EINVAL;
1281
1282 set_screen_base:
1283 linelen = xres_virtual * bpp / 8;
1284 if (yres_virtual * linelen > screen_len && screen_len)
1285 return -EINVAL;
1286 if (yres * linelen > screen_len && screen_len)
1287 return -EINVAL;
1288 if (var->yoffset + yres > yres_virtual && yres_virtual)
1289 return -EINVAL;
1290 par->yres_virtual = yres_virtual;
1291 par->screen_base = screen_base + var->yoffset * linelen;
1292 par->hw.falcon.xoffset = 0;
1293
1294 return 0;
1295 }
1296
1297 static int falcon_encode_var( struct fb_var_screeninfo *var,
1298 struct atafb_par *par )
1299 {
1300 /* !!! only for VGA !!! */
1301 int linelen;
1302 int prescale, plen;
1303 int hdb_off, hde_off, base_off;
1304 struct falcon_hw *hw = &par->hw.falcon;
1305
1306 memset(var, 0, sizeof(struct fb_var_screeninfo));
1307 /* possible frequencies: 25.175 or 32MHz */
1308 var->pixclock = hw->sync & 0x1 ? fext.t :
1309 hw->vid_control & VCO_CLOCK25 ? f25.t : f32.t;
1310
1311 var->height=-1;
1312 var->width=-1;
1313
1314 var->sync=0;
1315 if (hw->vid_control & VCO_HSYPOS)
1316 var->sync |= FB_SYNC_HOR_HIGH_ACT;
1317 if (hw->vid_control & VCO_VSYPOS)
1318 var->sync |= FB_SYNC_VERT_HIGH_ACT;
1319
1320 var->vmode = FB_VMODE_NONINTERLACED;
1321 if (hw->vid_mode & VMO_INTER)
1322 var->vmode |= FB_VMODE_INTERLACED;
1323 if (hw->vid_mode & VMO_DOUBLE)
1324 var->vmode |= FB_VMODE_DOUBLE;
1325
1326 /* visible y resolution:
1327 * Graphics display starts at line VDB and ends at line
1328 * VDE. If interlace mode off unit of VC-registers is
1329 * half lines, else lines.
1330 */
1331 var->yres = hw->vde - hw->vdb;
1332 if (!(var->vmode & FB_VMODE_INTERLACED))
1333 var->yres >>= 1;
1334 if (var->vmode & FB_VMODE_DOUBLE)
1335 var->yres >>= 1;
1336
1337 /* to get bpp, we must examine f_shift and st_shift.
1338 * f_shift is valid if any of bits no. 10, 8 or 4
1339 * is set. Priority in f_shift is: 10 ">" 8 ">" 4, i.e.
1340 * if bit 10 set then bit 8 and bit 4 don't care...
1341 * If all these bits are 0 get display depth from st_shift
1342 * (as for ST and STE)
1343 */
1344 if (hw->f_shift & 0x400) /* 2 colors */
1345 var->bits_per_pixel = 1;
1346 else if (hw->f_shift & 0x100) /* hicolor */
1347 var->bits_per_pixel = 16;
1348 else if (hw->f_shift & 0x010) /* 8 bitplanes */
1349 var->bits_per_pixel = 8;
1350 else if (hw->st_shift == 0)
1351 var->bits_per_pixel = 4;
1352 else if (hw->st_shift == 0x100)
1353 var->bits_per_pixel = 2;
1354 else /* if (hw->st_shift == 0x200) */
1355 var->bits_per_pixel = 1;
1356
1357 var->xres = hw->line_width * 16 / var->bits_per_pixel;
1358 var->xres_virtual = var->xres + hw->line_offset * 16 / var->bits_per_pixel;
1359 if (hw->xoffset)
1360 var->xres_virtual += 16;
1361
1362 if (var->bits_per_pixel == 16) {
1363 var->red.offset=11;
1364 var->red.length=5;
1365 var->red.msb_right=0;
1366 var->green.offset=5;
1367 var->green.length=6;
1368 var->green.msb_right=0;
1369 var->blue.offset=0;
1370 var->blue.length=5;
1371 var->blue.msb_right=0;
1372 }
1373 else {
1374 var->red.offset=0;
1375 var->red.length = hw->ste_mode ? 4 : 6;
1376 var->red.msb_right=0;
1377 var->grayscale=0;
1378 var->blue=var->green=var->red;
1379 }
1380 var->transp.offset=0;
1381 var->transp.length=0;
1382 var->transp.msb_right=0;
1383
1384 linelen = var->xres_virtual * var->bits_per_pixel / 8;
1385 if (screen_len) {
1386 if (par->yres_virtual)
1387 var->yres_virtual = par->yres_virtual;
1388 else
1389 /* yres_virtual==0 means use maximum */
1390 var->yres_virtual = screen_len / linelen;
1391 }
1392 else {
1393 if (hwscroll < 0)
1394 var->yres_virtual = 2 * var->yres;
1395 else
1396 var->yres_virtual=var->yres+hwscroll * 16;
1397 }
1398 var->xoffset=0; /* TODO change this */
1399
1400 /* hdX-offsets */
1401 prescale = hxx_prescale(hw);
1402 plen = 4 >> (hw->vid_mode >> 2 & 0x3);
1403 base_off = hw->vid_control & VCO_SHORTOFFS ? 64 : 128;
1404 if (hw->f_shift & 0x100) {
1405 hde_off = 0;
1406 hdb_off = (base_off + 16 * plen) + prescale;
1407 }
1408 else {
1409 hde_off = ((128 / var->bits_per_pixel + 2) * plen);
1410 if (hw->ste_mode)
1411 hdb_off = (64 + base_off + (128 / var->bits_per_pixel + 2) * plen)
1412 + prescale;
1413 else
1414 hdb_off = (base_off + (128 / var->bits_per_pixel + 18) * plen)
1415 + prescale;
1416 }
1417
1418 /* Right margin includes hsync */
1419 var->left_margin = hdb_off + prescale * ((hw->hdb & 0x1ff) -
1420 (hw->hdb & 0x200 ? 2+hw->hht : 0));
1421 if (hw->ste_mode || mon_type!=F_MON_VGA)
1422 var->right_margin = prescale * (hw->hht + 2 - hw->hde) - hde_off;
1423 else
1424 /* can't use this in ste_mode, because hbb is +1 off */
1425 var->right_margin = prescale * (hw->hht + 2 - hw->hbb);
1426 var->hsync_len = prescale * (hw->hht + 2 - hw->hss);
1427
1428 /* Lower margin includes vsync */
1429 var->upper_margin = hw->vdb / 2 ; /* round down to full lines */
1430 var->lower_margin = (hw->vft+1 - hw->vde + 1) / 2; /* round up */
1431 var->vsync_len = (hw->vft+1 - hw->vss + 1) / 2; /* round up */
1432 if (var->vmode & FB_VMODE_INTERLACED) {
1433 var->upper_margin *= 2;
1434 var->lower_margin *= 2;
1435 var->vsync_len *= 2;
1436 }
1437 else if (var->vmode & FB_VMODE_DOUBLE) {
1438 var->upper_margin = (var->upper_margin + 1) / 2;
1439 var->lower_margin = (var->lower_margin + 1) / 2;
1440 var->vsync_len = (var->vsync_len + 1) / 2;
1441 }
1442
1443 var->pixclock *= plen;
1444 var->left_margin /= plen;
1445 var->right_margin /= plen;
1446 var->hsync_len /= plen;
1447
1448 var->right_margin -= var->hsync_len;
1449 var->lower_margin -= var->vsync_len;
1450
1451 if (screen_base)
1452 var->yoffset=(par->screen_base - screen_base)/linelen;
1453 else
1454 var->yoffset=0;
1455 var->nonstd=0; /* what is this for? */
1456 var->activate=0;
1457 return 0;
1458 }
1459
1460
1461 static int f_change_mode = 0;
1462 static struct falcon_hw f_new_mode;
1463 static int f_pan_display = 0;
1464
1465 static void falcon_get_par( struct atafb_par *par )
1466 {
1467 unsigned long addr;
1468 struct falcon_hw *hw = &par->hw.falcon;
1469
1470 hw->line_width = shifter_f030.scn_width;
1471 hw->line_offset = shifter_f030.off_next;
1472 hw->st_shift = videl.st_shift & 0x300;
1473 hw->f_shift = videl.f_shift;
1474 hw->vid_control = videl.control;
1475 hw->vid_mode = videl.mode;
1476 hw->sync = shifter.syncmode & 0x1;
1477 hw->xoffset = videl.xoffset & 0xf;
1478 hw->hht = videl.hht;
1479 hw->hbb = videl.hbb;
1480 hw->hbe = videl.hbe;
1481 hw->hdb = videl.hdb;
1482 hw->hde = videl.hde;
1483 hw->hss = videl.hss;
1484 hw->vft = videl.vft;
1485 hw->vbb = videl.vbb;
1486 hw->vbe = videl.vbe;
1487 hw->vdb = videl.vdb;
1488 hw->vde = videl.vde;
1489 hw->vss = videl.vss;
1490
1491 addr = (shifter.bas_hi & 0xff) << 16 |
1492 (shifter.bas_md & 0xff) << 8 |
1493 (shifter.bas_lo & 0xff);
1494 par->screen_base = phys_to_virt(addr);
1495
1496 /* derived parameters */
1497 hw->ste_mode = (hw->f_shift & 0x510)==0 && hw->st_shift==0x100;
1498 hw->mono = (hw->f_shift & 0x400) ||
1499 ((hw->f_shift & 0x510)==0 && hw->st_shift==0x200);
1500 }
1501
1502 static void falcon_set_par( struct atafb_par *par )
1503 {
1504 f_change_mode = 0;
1505
1506 /* only set screen_base if really necessary */
1507 if (current_par.screen_base != par->screen_base)
1508 fbhw->set_screen_base(par->screen_base);
1509
1510 /* Don't touch any other registers if we keep the default resolution */
1511 if (DontCalcRes)
1512 return;
1513
1514 /* Tell vbl-handler to change video mode.
1515 * We change modes only on next VBL, to avoid desynchronisation
1516 * (a shift to the right and wrap around by a random number of pixels
1517 * in all monochrome modes).
1518 * This seems to work on my Falcon.
1519 */
1520 f_new_mode = par->hw.falcon;
1521 f_change_mode = 1;
1522 }
1523
1524
1525 static irqreturn_t falcon_vbl_switcher( int irq, void *dummy, struct pt_regs *fp )
1526 {
1527 struct falcon_hw *hw = &f_new_mode;
1528
1529 if (f_change_mode) {
1530 f_change_mode = 0;
1531
1532 if (hw->sync & 0x1) {
1533 /* Enable external pixelclock. This code only for ScreenWonder */
1534 *(volatile unsigned short*)0xffff9202 = 0xffbf;
1535 }
1536 else {
1537 /* Turn off external clocks. Read sets all output bits to 1. */
1538 *(volatile unsigned short*)0xffff9202;
1539 }
1540 shifter.syncmode = hw->sync;
1541
1542 videl.hht = hw->hht;
1543 videl.hbb = hw->hbb;
1544 videl.hbe = hw->hbe;
1545 videl.hdb = hw->hdb;
1546 videl.hde = hw->hde;
1547 videl.hss = hw->hss;
1548 videl.vft = hw->vft;
1549 videl.vbb = hw->vbb;
1550 videl.vbe = hw->vbe;
1551 videl.vdb = hw->vdb;
1552 videl.vde = hw->vde;
1553 videl.vss = hw->vss;
1554
1555 videl.f_shift = 0; /* write enables Falcon palette, 0: 4 planes */
1556 if (hw->ste_mode) {
1557 videl.st_shift = hw->st_shift; /* write enables STE palette */
1558 }
1559 else {
1560 /* IMPORTANT:
1561 * set st_shift 0, so we can tell the screen-depth if f_shift==0.
1562 * Writing 0 to f_shift enables 4 plane Falcon mode but
1563 * doesn't set st_shift. st_shift!=0 (!=4planes) is impossible
1564 * with Falcon palette.
1565 */
1566 videl.st_shift = 0;
1567 /* now back to Falcon palette mode */
1568 videl.f_shift = hw->f_shift;
1569 }
1570 /* writing to st_shift changed scn_width and vid_mode */
1571 videl.xoffset = hw->xoffset;
1572 shifter_f030.scn_width = hw->line_width;
1573 shifter_f030.off_next = hw->line_offset;
1574 videl.control = hw->vid_control;
1575 videl.mode = hw->vid_mode;
1576 }
1577 if (f_pan_display) {
1578 f_pan_display = 0;
1579 videl.xoffset = current_par.hw.falcon.xoffset;
1580 shifter_f030.off_next = current_par.hw.falcon.line_offset;
1581 }
1582 return IRQ_HANDLED;
1583 }
1584
1585
1586 static int falcon_pan_display( struct fb_var_screeninfo *var,
1587 struct atafb_par *par )
1588 {
1589 int xoffset;
1590 int bpp = fb_display[fb_info.currcon].var.bits_per_pixel;
1591
1592 if (bpp == 1)
1593 var->xoffset = up(var->xoffset, 32);
1594 if (bpp != 16)
1595 par->hw.falcon.xoffset = var->xoffset & 15;
1596 else {
1597 par->hw.falcon.xoffset = 0;
1598 var->xoffset = up(var->xoffset, 2);
1599 }
1600 par->hw.falcon.line_offset = bpp *
1601 (fb_display[fb_info.currcon].var.xres_virtual - fb_display[fb_info.currcon].var.xres) / 16;
1602 if (par->hw.falcon.xoffset)
1603 par->hw.falcon.line_offset -= bpp;
1604 xoffset = var->xoffset - par->hw.falcon.xoffset;
1605
1606 par->screen_base = screen_base +
1607 (var->yoffset * fb_display[fb_info.currcon].var.xres_virtual + xoffset) * bpp / 8;
1608 if (fbhw->set_screen_base)
1609 fbhw->set_screen_base (par->screen_base);
1610 else
1611 return -EINVAL; /* shouldn't happen */
1612 f_pan_display = 1;
1613 return 0;
1614 }
1615
1616
1617 static int falcon_getcolreg( unsigned regno, unsigned *red,
1618 unsigned *green, unsigned *blue,
1619 unsigned *transp, struct fb_info *info )
1620 { unsigned long col;
1621
1622 if (regno > 255)
1623 return 1;
1624 /* This works in STE-mode (with 4bit/color) since f030_col-registers
1625 * hold up to 6bit/color.
1626 * Even with hicolor r/g/b=5/6/5 bit!
1627 */
1628 col = f030_col[regno];
1629 *red = (col >> 16) & 0xff00;
1630 *green = (col >> 8) & 0xff00;
1631 *blue = (col << 8) & 0xff00;
1632 *transp = 0;
1633 return 0;
1634 }
1635
1636
1637 static int falcon_setcolreg( unsigned regno, unsigned red,
1638 unsigned green, unsigned blue,
1639 unsigned transp, struct fb_info *info )
1640 {
1641 if (regno > 255)
1642 return 1;
1643 f030_col[regno] = (((red & 0xfc00) << 16) |
1644 ((green & 0xfc00) << 8) |
1645 ((blue & 0xfc00) >> 8));
1646 if (regno < 16) {
1647 shifter_tt.color_reg[regno] =
1648 (((red & 0xe000) >> 13) | ((red & 0x1000) >> 12) << 8) |
1649 (((green & 0xe000) >> 13) | ((green & 0x1000) >> 12) << 4) |
1650 ((blue & 0xe000) >> 13) | ((blue & 0x1000) >> 12);
1651 #ifdef FBCON_HAS_CFB16
1652 fbcon_cfb16_cmap[regno] = ((red & 0xf800) |
1653 ((green & 0xfc00) >> 5) |
1654 ((blue & 0xf800) >> 11));
1655 #endif
1656 }
1657 return 0;
1658 }
1659
1660
1661 static int falcon_blank( int blank_mode )
1662 {
1663 /* ++guenther: we can switch off graphics by changing VDB and VDE,
1664 * so VIDEL doesn't hog the bus while saving.
1665 * (this may affect usleep()).
1666 */
1667 int vdb, vss, hbe, hss;
1668
1669 if (mon_type == F_MON_SM) /* this doesn't work on SM124 */
1670 return 1;
1671
1672 vdb = current_par.VDB;
1673 vss = current_par.VSS;
1674 hbe = current_par.HBE;
1675 hss = current_par.HSS;
1676
1677 if (blank_mode >= 1) {
1678 /* disable graphics output (this speeds up the CPU) ... */
1679 vdb = current_par.VFT + 1;
1680 /* ... and blank all lines */
1681 hbe = current_par.HHT + 2;
1682 }
1683 /* use VESA suspend modes on VGA monitors */
1684 if (mon_type == F_MON_VGA) {
1685 if (blank_mode == 2 || blank_mode == 4)
1686 vss = current_par.VFT + 1;
1687 if (blank_mode == 3 || blank_mode == 4)
1688 hss = current_par.HHT + 2;
1689 }
1690
1691 videl.vdb = vdb;
1692 videl.vss = vss;
1693 videl.hbe = hbe;
1694 videl.hss = hss;
1695
1696 return 0;
1697 }
1698
1699
1700 static int falcon_detect( void )
1701 {
1702 struct atafb_par par;
1703 unsigned char fhw;
1704
1705 /* Determine connected monitor and set monitor parameters */
1706 fhw = *(unsigned char*)0xffff8006;
1707 mon_type = fhw >> 6 & 0x3;
1708 /* bit 1 of fhw: 1=32 bit ram bus, 0=16 bit */
1709 f030_bus_width = fhw << 6 & 0x80;
1710 switch (mon_type) {
1711 case F_MON_SM:
1712 fb_info.monspecs.vfmin = 70;
1713 fb_info.monspecs.vfmax = 72;
1714 fb_info.monspecs.hfmin = 35713;
1715 fb_info.monspecs.hfmax = 35715;
1716 break;
1717 case F_MON_SC:
1718 case F_MON_TV:
1719 /* PAL...NTSC */
1720 fb_info.monspecs.vfmin = 49; /* not 50, since TOS defaults to 49.9x Hz */
1721 fb_info.monspecs.vfmax = 60;
1722 fb_info.monspecs.hfmin = 15620;
1723 fb_info.monspecs.hfmax = 15755;
1724 break;
1725 }
1726 /* initialize hsync-len */
1727 f25.hsync = h_syncs[mon_type] / f25.t;
1728 f32.hsync = h_syncs[mon_type] / f32.t;
1729 if (fext.t)
1730 fext.hsync = h_syncs[mon_type] / fext.t;
1731
1732 falcon_get_par(&par);
1733 falcon_encode_var(&atafb_predefined[0], &par);
1734
1735 /* Detected mode is always the "autodetect" slot */
1736 return 1;
1737 }
1738
1739 #endif /* ATAFB_FALCON */
1740
1741 /* ------------------- ST(E) specific functions ---------------------- */
1742
1743 #ifdef ATAFB_STE
1744
1745 static int stste_encode_fix( struct fb_fix_screeninfo *fix,
1746 struct atafb_par *par )
1747
1748 {
1749 int mode;
1750
1751 strcpy(fix->id,"Atari Builtin");
1752 fix->smem_start = (unsigned long)real_screen_base;
1753 fix->smem_len = screen_len;
1754 fix->type = FB_TYPE_INTERLEAVED_PLANES;
1755 fix->type_aux = 2;
1756 fix->visual = FB_VISUAL_PSEUDOCOLOR;
1757 mode = par->hw.st.mode & 3;
1758 if (mode == ST_HIGH) {
1759 fix->type = FB_TYPE_PACKED_PIXELS;
1760 fix->type_aux = 0;
1761 fix->visual = FB_VISUAL_MONO10;
1762 }
1763 if (ATARIHW_PRESENT(EXTD_SHIFTER)) {
1764 fix->xpanstep = 16;
1765 fix->ypanstep = 1;
1766 } else {
1767 fix->xpanstep = 0;
1768 fix->ypanstep = 0;
1769 }
1770 fix->ywrapstep = 0;
1771 fix->line_length = 0;
1772 fix->accel = FB_ACCEL_ATARIBLITT;
1773 return 0;
1774 }
1775
1776
1777 static int stste_decode_var( struct fb_var_screeninfo *var,
1778 struct atafb_par *par )
1779 {
1780 int xres=var->xres;
1781 int yres=var->yres;
1782 int bpp=var->bits_per_pixel;
1783 int linelen;
1784 int yres_virtual = var->yres_virtual;
1785
1786 if (mono_moni) {
1787 if (bpp > 1 || xres > sttt_xres || yres > st_yres)
1788 return -EINVAL;
1789 par->hw.st.mode=ST_HIGH;
1790 xres=sttt_xres;
1791 yres=st_yres;
1792 bpp=1;
1793 } else {
1794 if (bpp > 4 || xres > sttt_xres || yres > st_yres)
1795 return -EINVAL;
1796 if (bpp > 2) {
1797 if (xres > sttt_xres/2 || yres > st_yres/2)
1798 return -EINVAL;
1799 par->hw.st.mode=ST_LOW;
1800 xres=sttt_xres/2;
1801 yres=st_yres/2;
1802 bpp=4;
1803 }
1804 else if (bpp > 1) {
1805 if (xres > sttt_xres || yres > st_yres/2)
1806 return -EINVAL;
1807 par->hw.st.mode=ST_MID;
1808 xres=sttt_xres;
1809 yres=st_yres/2;
1810 bpp=2;
1811 }
1812 else
1813 return -EINVAL;
1814 }
1815 if (yres_virtual <= 0)
1816 yres_virtual = 0;
1817 else if (yres_virtual < yres)
1818 yres_virtual = yres;
1819 if (var->sync & FB_SYNC_EXT)
1820 par->hw.st.sync=(par->hw.st.sync & ~1) | 1;
1821 else
1822 par->hw.st.sync=(par->hw.st.sync & ~1);
1823 linelen=xres*bpp/8;
1824 if (yres_virtual * linelen > screen_len && screen_len)
1825 return -EINVAL;
1826 if (yres * linelen > screen_len && screen_len)
1827 return -EINVAL;
1828 if (var->yoffset + yres > yres_virtual && yres_virtual)
1829 return -EINVAL;
1830 par->yres_virtual = yres_virtual;
1831 par->screen_base=screen_base+ var->yoffset*linelen;
1832 return 0;
1833 }
1834
1835 static int stste_encode_var( struct fb_var_screeninfo *var,
1836 struct atafb_par *par )
1837 {
1838 int linelen;
1839 memset(var, 0, sizeof(struct fb_var_screeninfo));
1840 var->red.offset=0;
1841 var->red.length = ATARIHW_PRESENT(EXTD_SHIFTER) ? 4 : 3;
1842 var->red.msb_right=0;
1843 var->grayscale=0;
1844
1845 var->pixclock=31041;
1846 var->left_margin=120; /* these are incorrect */
1847 var->right_margin=100;
1848 var->upper_margin=8;
1849 var->lower_margin=16;
1850 var->hsync_len=140;
1851 var->vsync_len=30;
1852
1853 var->height=-1;
1854 var->width=-1;
1855
1856 if (!(par->hw.st.sync & 1))
1857 var->sync=0;
1858 else
1859 var->sync=FB_SYNC_EXT;
1860
1861 switch (par->hw.st.mode & 3) {
1862 case ST_LOW:
1863 var->xres=sttt_xres/2;
1864 var->yres=st_yres/2;
1865 var->bits_per_pixel=4;
1866 break;
1867 case ST_MID:
1868 var->xres=sttt_xres;
1869 var->yres=st_yres/2;
1870 var->bits_per_pixel=2;
1871 break;
1872 case ST_HIGH:
1873 var->xres=sttt_xres;
1874 var->yres=st_yres;
1875 var->bits_per_pixel=1;
1876 break;
1877 }
1878 var->blue=var->green=var->red;
1879 var->transp.offset=0;
1880 var->transp.length=0;
1881 var->transp.msb_right=0;
1882 var->xres_virtual=sttt_xres_virtual;
1883 linelen=var->xres_virtual * var->bits_per_pixel / 8;
1884 ovsc_addlen=linelen*(sttt_yres_virtual - st_yres);
1885
1886 if (! use_hwscroll)
1887 var->yres_virtual=var->yres;
1888 else if (screen_len) {
1889 if (par->yres_virtual)
1890 var->yres_virtual = par->yres_virtual;
1891 else
1892 /* yres_virtual==0 means use maximum */
1893 var->yres_virtual = screen_len / linelen;
1894 }
1895 else {
1896 if (hwscroll < 0)
1897 var->yres_virtual = 2 * var->yres;
1898 else
1899 var->yres_virtual=var->yres+hwscroll * 16;
1900 }
1901 var->xoffset=0;
1902 if (screen_base)
1903 var->yoffset=(par->screen_base - screen_base)/linelen;
1904 else
1905 var->yoffset=0;
1906 var->nonstd=0;
1907 var->activate=0;
1908 var->vmode=FB_VMODE_NONINTERLACED;
1909 return 0;
1910 }
1911
1912
1913 static void stste_get_par( struct atafb_par *par )
1914 {
1915 unsigned long addr;
1916 par->hw.st.mode=shifter_tt.st_shiftmode;
1917 par->hw.st.sync=shifter.syncmode;
1918 addr = ((shifter.bas_hi & 0xff) << 16) |
1919 ((shifter.bas_md & 0xff) << 8);
1920 if (ATARIHW_PRESENT(EXTD_SHIFTER))
1921 addr |= (shifter.bas_lo & 0xff);
1922 par->screen_base = phys_to_virt(addr);
1923 }
1924
1925 static void stste_set_par( struct atafb_par *par )
1926 {
1927 shifter_tt.st_shiftmode=par->hw.st.mode;
1928 shifter.syncmode=par->hw.st.sync;
1929 /* only set screen_base if really necessary */
1930 if (current_par.screen_base != par->screen_base)
1931 fbhw->set_screen_base(par->screen_base);
1932 }
1933
1934
1935 static int stste_getcolreg(unsigned regno, unsigned *red,
1936 unsigned *green, unsigned *blue,
1937 unsigned *transp, struct fb_info *info)
1938 {
1939 unsigned col, t;
1940
1941 if (regno > 15)
1942 return 1;
1943 col = shifter_tt.color_reg[regno];
1944 if (ATARIHW_PRESENT(EXTD_SHIFTER)) {
1945 t = ((col >> 7) & 0xe) | ((col >> 11) & 1);
1946 t |= t << 4;
1947 *red = t | (t << 8);
1948 t = ((col >> 3) & 0xe) | ((col >> 7) & 1);
1949 t |= t << 4;
1950 *green = t | (t << 8);
1951 t = ((col << 1) & 0xe) | ((col >> 3) & 1);
1952 t |= t << 4;
1953 *blue = t | (t << 8);
1954 }
1955 else {
1956 t = (col >> 7) & 0xe;
1957 t |= t << 4;
1958 *red = t | (t << 8);
1959 t = (col >> 3) & 0xe;
1960 t |= t << 4;
1961 *green = t | (t << 8);
1962 t = (col << 1) & 0xe;
1963 t |= t << 4;
1964 *blue = t | (t << 8);
1965 }
1966 *transp = 0;
1967 return 0;
1968 }
1969
1970
1971 static int stste_setcolreg(unsigned regno, unsigned red,
1972 unsigned green, unsigned blue,
1973 unsigned transp, struct fb_info *info)
1974 {
1975 if (regno > 15)
1976 return 1;
1977 red >>= 12;
1978 blue >>= 12;
1979 green >>= 12;
1980 if (ATARIHW_PRESENT(EXTD_SHIFTER))
1981 shifter_tt.color_reg[regno] =
1982 (((red & 0xe) >> 1) | ((red & 1) << 3) << 8) |
1983 (((green & 0xe) >> 1) | ((green & 1) << 3) << 4) |
1984 ((blue & 0xe) >> 1) | ((blue & 1) << 3);
1985 else
1986 shifter_tt.color_reg[regno] =
1987 ((red & 0xe) << 7) |
1988 ((green & 0xe) << 3) |
1989 ((blue & 0xe) >> 1);
1990 return 0;
1991 }
1992
1993
1994 static int stste_detect( void )
1995
1996 { struct atafb_par par;
1997
1998 /* Determine the connected monitor: The DMA sound must be
1999 * disabled before reading the MFP GPIP, because the Sound
2000 * Done Signal and the Monochrome Detect are XORed together!
2001 */
2002 if (ATARIHW_PRESENT(PCM_8BIT)) {
2003 tt_dmasnd.ctrl = DMASND_CTRL_OFF;
2004 udelay(20); /* wait a while for things to settle down */
2005 }
2006 mono_moni = (mfp.par_dt_reg & 0x80) == 0;
2007
2008 stste_get_par(&par);
2009 stste_encode_var(&atafb_predefined[0], &par);
2010
2011 if (!ATARIHW_PRESENT(EXTD_SHIFTER))
2012 use_hwscroll = 0;
2013 return 1;
2014 }
2015
2016 static void stste_set_screen_base(void *s_base)
2017 {
2018 unsigned long addr;
2019 addr= virt_to_phys(s_base);
2020 /* Setup Screen Memory */
2021 shifter.bas_hi=(unsigned char) ((addr & 0xff0000) >> 16);
2022 shifter.bas_md=(unsigned char) ((addr & 0x00ff00) >> 8);
2023 if (ATARIHW_PRESENT(EXTD_SHIFTER))
2024 shifter.bas_lo=(unsigned char) (addr & 0x0000ff);
2025 }
2026
2027 #endif /* ATAFB_STE */
2028
2029 /* Switching the screen size should be done during vsync, otherwise
2030 * the margins may get messed up. This is a well known problem of
2031 * the ST's video system.
2032 *
2033 * Unfortunately there is hardly any way to find the vsync, as the
2034 * vertical blank interrupt is no longer in time on machines with
2035 * overscan type modifications.
2036 *
2037 * We can, however, use Timer B to safely detect the black shoulder,
2038 * but then we've got to guess an appropriate delay to find the vsync.
2039 * This might not work on every machine.
2040 *
2041 * martin_rogge @ ki.maus.de, 8th Aug 1995
2042 */
2043
2044 #define LINE_DELAY (mono_moni ? 30 : 70)
2045 #define SYNC_DELAY (mono_moni ? 1500 : 2000)
2046
2047 /* SWITCH_ACIA may be used for Falcon (ScreenBlaster III internal!) */
2048 static void st_ovsc_switch(void)
2049 {
2050 unsigned long flags;
2051 register unsigned char old, new;
2052
2053 if (!(atari_switches & ATARI_SWITCH_OVSC_MASK))
2054 return;
2055 local_irq_save(flags);
2056
2057 mfp.tim_ct_b = 0x10;
2058 mfp.active_edge |= 8;
2059 mfp.tim_ct_b = 0;
2060 mfp.tim_dt_b = 0xf0;
2061 mfp.tim_ct_b = 8;
2062 while (mfp.tim_dt_b > 1) /* TOS does it this way, don't ask why */
2063 ;
2064 new = mfp.tim_dt_b;
2065 do {
2066 udelay(LINE_DELAY);
2067 old = new;
2068 new = mfp.tim_dt_b;
2069 } while (old != new);
2070 mfp.tim_ct_b = 0x10;
2071 udelay(SYNC_DELAY);
2072
2073 if (atari_switches & ATARI_SWITCH_OVSC_IKBD)
2074 acia.key_ctrl = ACIA_DIV64 | ACIA_D8N1S | ACIA_RHTID | ACIA_RIE;
2075 if (atari_switches & ATARI_SWITCH_OVSC_MIDI)
2076 acia.mid_ctrl = ACIA_DIV16 | ACIA_D8N1S | ACIA_RHTID;
2077 if (atari_switches & (ATARI_SWITCH_OVSC_SND6|ATARI_SWITCH_OVSC_SND7)) {
2078 sound_ym.rd_data_reg_sel = 14;
2079 sound_ym.wd_data = sound_ym.rd_data_reg_sel |
2080 ((atari_switches&ATARI_SWITCH_OVSC_SND6) ? 0x40:0) |
2081 ((atari_switches&ATARI_SWITCH_OVSC_SND7) ? 0x80:0);
2082 }
2083 local_irq_restore(flags);
2084 }
2085
2086 /* ------------------- External Video ---------------------- */
2087
2088 #ifdef ATAFB_EXT
2089
2090 static int ext_encode_fix( struct fb_fix_screeninfo *fix,
2091 struct atafb_par *par )
2092
2093 {
2094 strcpy(fix->id,"Unknown Extern");
2095 fix->smem_start = (unsigned long)external_addr;
2096 fix->smem_len = PAGE_ALIGN(external_len);
2097 if (external_depth == 1) {
2098 fix->type = FB_TYPE_PACKED_PIXELS;
2099 /* The letters 'n' and 'i' in the "atavideo=external:" stand
2100 * for "normal" and "inverted", rsp., in the monochrome case */
2101 fix->visual =
2102 (external_pmode == FB_TYPE_INTERLEAVED_PLANES ||
2103 external_pmode == FB_TYPE_PACKED_PIXELS) ?
2104 FB_VISUAL_MONO10 :
2105 FB_VISUAL_MONO01;
2106 }
2107 else {
2108 /* Use STATIC if we don't know how to access color registers */
2109 int visual = external_vgaiobase ?
2110 FB_VISUAL_PSEUDOCOLOR :
2111 FB_VISUAL_STATIC_PSEUDOCOLOR;
2112 switch (external_pmode) {
2113 case -1: /* truecolor */
2114 fix->type=FB_TYPE_PACKED_PIXELS;
2115 fix->visual=FB_VISUAL_TRUECOLOR;
2116 break;
2117 case FB_TYPE_PACKED_PIXELS:
2118 fix->type=FB_TYPE_PACKED_PIXELS;
2119 fix->visual=visual;
2120 break;
2121 case FB_TYPE_PLANES:
2122 fix->type=FB_TYPE_PLANES;
2123 fix->visual=visual;
2124 break;
2125 case FB_TYPE_INTERLEAVED_PLANES:
2126 fix->type=FB_TYPE_INTERLEAVED_PLANES;
2127 fix->type_aux=2;
2128 fix->visual=visual;
2129 break;
2130 }
2131 }
2132 fix->xpanstep = 0;
2133 fix->ypanstep = 0;
2134 fix->ywrapstep = 0;
2135 fix->line_length = 0;
2136 return 0;
2137 }
2138
2139
2140 static int ext_decode_var( struct fb_var_screeninfo *var,
2141 struct atafb_par *par )
2142 {
2143 struct fb_var_screeninfo *myvar = &atafb_predefined[0];
2144
2145 if (var->bits_per_pixel > myvar->bits_per_pixel ||
2146 var->xres > myvar->xres ||
2147 var->xres_virtual > myvar->xres_virtual ||
2148 var->yres > myvar->yres ||
2149 var->xoffset > 0 ||
2150 var->yoffset > 0)
2151 return -EINVAL;
2152 return 0;
2153 }
2154
2155
2156 static int ext_encode_var( struct fb_var_screeninfo *var,
2157 struct atafb_par *par )
2158 {
2159 memset(var, 0, sizeof(struct fb_var_screeninfo));
2160 var->red.offset=0;
2161 var->red.length=(external_pmode == -1) ? external_depth/3 :
2162 (external_vgaiobase ? external_bitspercol : 0);
2163 var->red.msb_right=0;
2164 var->grayscale=0;
2165
2166 var->pixclock=31041;
2167 var->left_margin=120; /* these are surely incorrect */
2168 var->right_margin=100;
2169 var->upper_margin=8;
2170 var->lower_margin=16;
2171 var->hsync_len=140;
2172 var->vsync_len=30;
2173
2174 var->height=-1;
2175 var->width=-1;
2176
2177 var->sync=0;
2178
2179 var->xres = external_xres;
2180 var->yres = external_yres;
2181 var->xres_virtual = external_xres_virtual;
2182 var->bits_per_pixel = external_depth;
2183
2184 var->blue=var->green=var->red;
2185 var->transp.offset=0;
2186 var->transp.length=0;
2187 var->transp.msb_right=0;
2188 var->yres_virtual=var->yres;
2189 var->xoffset=0;
2190 var->yoffset=0;
2191 var->nonstd=0;
2192 var->activate=0;
2193 var->vmode=FB_VMODE_NONINTERLACED;
2194 return 0;
2195 }
2196
2197
2198 static void ext_get_par( struct atafb_par *par )
2199 {
2200 par->screen_base = external_addr;
2201 }
2202
2203 static void ext_set_par( struct atafb_par *par )
2204 {
2205 }
2206
2207 #define OUTB(port,val) \
2208 *((unsigned volatile char *) ((port)+external_vgaiobase))=(val)
2209 #define INB(port) \
2210 (*((unsigned volatile char *) ((port)+external_vgaiobase)))
2211 #define DACDelay \
2212 do { \
2213 unsigned char tmp=INB(0x3da); \
2214 tmp=INB(0x3da); \
2215 } while (0)
2216
2217 static int ext_getcolreg( unsigned regno, unsigned *red,
2218 unsigned *green, unsigned *blue,
2219 unsigned *transp, struct fb_info *info )
2220 {
2221 if (! external_vgaiobase)
2222 return 1;
2223
2224 *red = ext_color[regno].red;
2225 *green = ext_color[regno].green;
2226 *blue = ext_color[regno].blue;
2227 *transp=0;
2228 return 0;
2229 }
2230
2231 static int ext_setcolreg( unsigned regno, unsigned red,
2232 unsigned green, unsigned blue,
2233 unsigned transp, struct fb_info *info )
2234
2235 { unsigned char colmask = (1 << external_bitspercol) - 1;
2236
2237 if (! external_vgaiobase)
2238 return 1;
2239
2240 ext_color[regno].red = red;
2241 ext_color[regno].green = green;
2242 ext_color[regno].blue = blue;
2243
2244 switch (external_card_type) {
2245 case IS_VGA:
2246 OUTB(0x3c8, regno);
2247 DACDelay;
2248 OUTB(0x3c9, red & colmask);
2249 DACDelay;
2250 OUTB(0x3c9, green & colmask);
2251 DACDelay;
2252 OUTB(0x3c9, blue & colmask);
2253 DACDelay;
2254 return 0;
2255
2256 case IS_MV300:
2257 OUTB((MV300_reg[regno] << 2)+1, red);
2258 OUTB((MV300_reg[regno] << 2)+1, green);
2259 OUTB((MV300_reg[regno] << 2)+1, blue);
2260 return 0;
2261
2262 default:
2263 return 1;
2264 }
2265 }
2266
2267
2268 static int ext_detect( void )
2269
2270 {
2271 struct fb_var_screeninfo *myvar = &atafb_predefined[0];
2272 struct atafb_par dummy_par;
2273
2274 myvar->xres = external_xres;
2275 myvar->xres_virtual = external_xres_virtual;
2276 myvar->yres = external_yres;
2277 myvar->bits_per_pixel = external_depth;
2278 ext_encode_var(myvar, &dummy_par);
2279 return 1;
2280 }
2281
2282 #endif /* ATAFB_EXT */
2283
2284 /* ------ This is the same for most hardware types -------- */
2285
2286 static void set_screen_base(void *s_base)
2287 {
2288 unsigned long addr;
2289 addr= virt_to_phys(s_base);
2290 /* Setup Screen Memory */
2291 shifter.bas_hi=(unsigned char) ((addr & 0xff0000) >> 16);
2292 shifter.bas_md=(unsigned char) ((addr & 0x00ff00) >> 8);
2293 shifter.bas_lo=(unsigned char) (addr & 0x0000ff);
2294 }
2295
2296
2297 static int pan_display( struct fb_var_screeninfo *var,
2298 struct atafb_par *par )
2299 {
2300 if (!fbhw->set_screen_base ||
2301 (!ATARIHW_PRESENT(EXTD_SHIFTER) && var->xoffset))
2302 return -EINVAL;
2303 var->xoffset = up(var->xoffset, 16);
2304 par->screen_base = screen_base +
2305 (var->yoffset * fb_display[fb_info.currcon].var.xres_virtual + var->xoffset)
2306 * fb_display[fb_info.currcon].var.bits_per_pixel / 8;
2307 fbhw->set_screen_base (par->screen_base);
2308 return 0;
2309 }
2310
2311
2312 /* ------------ Interfaces to hardware functions ------------ */
2313
2314
2315 #ifdef ATAFB_TT
2316 static struct fb_hwswitch tt_switch = {
2317 tt_detect, tt_encode_fix, tt_decode_var, tt_encode_var,
2318 tt_get_par, tt_set_par, tt_getcolreg,
2319 set_screen_base, NULL, pan_display
2320 };
2321 #endif
2322
2323 #ifdef ATAFB_FALCON
2324 static struct fb_hwswitch falcon_switch = {
2325 falcon_detect, falcon_encode_fix, falcon_decode_var, falcon_encode_var,
2326 falcon_get_par, falcon_set_par, falcon_getcolreg,
2327 set_screen_base, falcon_blank, falcon_pan_display
2328 };
2329 #endif
2330
2331 #ifdef ATAFB_STE
2332 static struct fb_hwswitch st_switch = {
2333 stste_detect, stste_encode_fix, stste_decode_var, stste_encode_var,
2334 stste_get_par, stste_set_par, stste_getcolreg,
2335 stste_set_screen_base, NULL, pan_display
2336 };
2337 #endif
2338
2339 #ifdef ATAFB_EXT
2340 static struct fb_hwswitch ext_switch = {
2341 ext_detect, ext_encode_fix, ext_decode_var, ext_encode_var,
2342 ext_get_par, ext_set_par, ext_getcolreg, NULL, NULL, NULL
2343 };
2344 #endif
2345
2346
2347
2348 static void atafb_get_par( struct atafb_par *par )
2349 {
2350 if (current_par_valid) {
2351 *par=current_par;
2352 }
2353 else
2354 fbhw->get_par(par);
2355 }
2356
2357
2358 static void atafb_set_par( struct atafb_par *par )
2359 {
2360 fbhw->set_par(par);
2361 current_par=*par;
2362 current_par_valid=1;
2363 }
2364
2365
2366
2367 /* =========================================================== */
2368 /* ============== Hardware Independent Functions ============= */
2369 /* =========================================================== */
2370
2371
2372 /* used for hardware scrolling */
2373
2374 static int
2375 fb_update_var(int con, struct fb_info *info)
2376 {
2377 int off=fb_display[con].var.yoffset*fb_display[con].var.xres_virtual*
2378 fb_display[con].var.bits_per_pixel>>3;
2379
2380 current_par.screen_base=screen_base + off;
2381
2382 if (fbhw->set_screen_base)
2383 fbhw->set_screen_base(current_par.screen_base);
2384 return 0;
2385 }
2386
2387 static int
2388 do_fb_set_var(struct fb_var_screeninfo *var, int isactive)
2389 {
2390 int err,activate;
2391 struct atafb_par par;
2392 if ((err=fbhw->decode_var(var, &par)))
2393 return err;
2394 activate=var->activate;
2395 if (((var->activate & FB_ACTIVATE_MASK) == FB_ACTIVATE_NOW) && isactive)
2396 atafb_set_par(&par);
2397 fbhw->encode_var(var, &par);
2398 var->activate=activate;
2399 return 0;
2400 }
2401
2402 static int
2403 atafb_get_fix(struct fb_fix_screeninfo *fix, int con, struct fb_info *info)
2404 {
2405 struct atafb_par par;
2406 if (con == -1)
2407 atafb_get_par(&par);
2408 else {
2409 int err;
2410 if ((err=fbhw->decode_var(&fb_display[con].var,&par)))
2411 return err;
2412 }
2413 memset(fix, 0, sizeof(struct fb_fix_screeninfo));
2414 return fbhw->encode_fix(fix, &par);
2415 }
2416
2417 static int
2418 atafb_get_var(struct fb_var_screeninfo *var, int con, struct fb_info *info)
2419 {
2420 struct atafb_par par;
2421 if (con == -1) {
2422 atafb_get_par(&par);
2423 fbhw->encode_var(var, &par);
2424 }
2425 else
2426 *var=fb_display[con].var;
2427 return 0;
2428 }
2429
2430 static void
2431 atafb_set_disp(int con, struct fb_info *info)
2432 {
2433 struct fb_fix_screeninfo fix;
2434 struct fb_var_screeninfo var;
2435 struct display *display;
2436
2437 if (con >= 0)
2438 display = &fb_display[con];
2439 else
2440 display = &disp; /* used during initialization */
2441
2442 atafb_get_fix(&fix, con, info);
2443 atafb_get_var(&var, con, info);
2444 if (con == -1)
2445 con=0;
2446 info->screen_base = (void *)fix.smem_start;
2447 display->visual = fix.visual;
2448 display->type = fix.type;
2449 display->type_aux = fix.type_aux;
2450 display->ypanstep = fix.ypanstep;
2451 display->ywrapstep = fix.ywrapstep;
2452 display->line_length = fix.line_length;
2453 if (fix.visual != FB_VISUAL_PSEUDOCOLOR &&
2454 fix.visual != FB_VISUAL_DIRECTCOLOR)
2455 display->can_soft_blank = 0;
2456 else
2457 display->can_soft_blank = 1;
2458 display->inverse =
2459 (fix.visual == FB_VISUAL_MONO01 ? !inverse : inverse);
2460 switch (fix.type) {
2461 case FB_TYPE_INTERLEAVED_PLANES:
2462 switch (var.bits_per_pixel) {
2463 #ifdef FBCON_HAS_IPLAN2P2
2464 case 2:
2465 display->dispsw = &fbcon_iplan2p2;
2466 break;
2467 #endif
2468 #ifdef FBCON_HAS_IPLAN2P4
2469 case 4:
2470 display->dispsw = &fbcon_iplan2p4;
2471 break;
2472 #endif
2473 #ifdef FBCON_HAS_IPLAN2P8
2474 case 8:
2475 display->dispsw = &fbcon_iplan2p8;
2476 break;
2477 #endif
2478 }
2479 break;
2480 case FB_TYPE_PACKED_PIXELS:
2481 switch (var.bits_per_pixel) {
2482 #ifdef FBCON_HAS_MFB
2483 case 1:
2484 display->dispsw = &fbcon_mfb;
2485 break;
2486 #endif
2487 #ifdef FBCON_HAS_CFB8
2488 case 8:
2489 display->dispsw = &fbcon_cfb8;
2490 break;
2491 #endif
2492 #ifdef FBCON_HAS_CFB16
2493 case 16:
2494 display->dispsw = &fbcon_cfb16;
2495 display->dispsw_data = fbcon_cfb16_cmap;
2496 break;
2497 #endif
2498 }
2499 break;
2500 }
2501 }
2502
2503 static int
2504 atafb_set_var(struct fb_var_screeninfo *var, int con, struct fb_info *info)
2505 {
2506 int err,oldxres,oldyres,oldbpp,oldxres_virtual,
2507 oldyres_virtual,oldyoffset;
2508 if ((err=do_fb_set_var(var, con==info->currcon)))
2509 return err;
2510 if ((var->activate & FB_ACTIVATE_MASK) == FB_ACTIVATE_NOW) {
2511 oldxres=fb_display[con].var.xres;
2512 oldyres=fb_display[con].var.yres;
2513 oldxres_virtual=fb_display[con].var.xres_virtual;
2514 oldyres_virtual=fb_display[con].var.yres_virtual;
2515 oldbpp=fb_display[con].var.bits_per_pixel;
2516 oldyoffset=fb_display[con].var.yoffset;
2517 fb_display[con].var=*var;
2518 if (oldxres != var->xres || oldyres != var->yres
2519 || oldxres_virtual != var->xres_virtual
2520 || oldyres_virtual != var->yres_virtual
2521 || oldbpp != var->bits_per_pixel
2522 || oldyoffset != var->yoffset) {
2523 atafb_set_disp(con, info);
2524 (*fb_info.changevar)(con);
2525 fb_alloc_cmap(&fb_display[con].cmap, 0, 0);
2526 do_install_cmap(con, info);
2527 }
2528 }
2529 var->activate=0;
2530 return 0;
2531 }
2532
2533
2534
2535 static int
2536 atafb_get_cmap(struct fb_cmap *cmap, int kspc, int con, struct fb_info *info)
2537 {
2538 if (con == info->currcon) /* current console ? */
2539 return fb_get_cmap(cmap, kspc, fbhw->getcolreg, info);
2540 else
2541 if (fb_display[con].cmap.len) /* non default colormap ? */
2542 fb_copy_cmap(&fb_display[con].cmap, cmap, kspc ? 0 : 2);
2543 else
2544 fb_copy_cmap(fb_default_cmap(1<<fb_display[con].var.bits_per_pixel),
2545 cmap, kspc ? 0 : 2);
2546 return 0;
2547 }
2548
2549 static int
2550 atafb_pan_display(struct fb_var_screeninfo *var, int con, struct fb_info *info)
2551 {
2552 int xoffset = var->xoffset;
2553 int yoffset = var->yoffset;
2554 int err;
2555
2556 if ( xoffset < 0 || xoffset + fb_display[con].var.xres > fb_display[con].var.xres_virtual
2557 || yoffset < 0 || yoffset + fb_display[con].var.yres > fb_display[con].var.yres_virtual)
2558 return -EINVAL;
2559
2560 if (con == info->currcon) {
2561 if (fbhw->pan_display) {
2562 if ((err = fbhw->pan_display(var, &current_par)))
2563 return err;
2564 }
2565 else
2566 return -EINVAL;
2567 }
2568 fb_display[con].var.xoffset = var->xoffset;
2569 fb_display[con].var.yoffset = var->yoffset;
2570 return 0;
2571 }
2572
2573 static int
2574 atafb_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
2575 unsigned long arg, int con, struct fb_info *info)
2576 {
2577 switch (cmd) {
2578 #ifdef FBCMD_GET_CURRENTPAR
2579 case FBCMD_GET_CURRENTPAR:
2580 if (copy_to_user((void *)arg, (void *)&current_par,
2581 sizeof(struct atafb_par)))
2582 return -EFAULT;
2583 return 0;
2584 #endif
2585 #ifdef FBCMD_SET_CURRENTPAR
2586 case FBCMD_SET_CURRENTPAR:
2587 if (copy_from_user((void *)&current_par, (void *)arg,
2588 sizeof(struct atafb_par)))
2589 return -EFAULT;
2590 atafb_set_par(&current_par);
2591 return 0;
2592 #endif
2593 }
2594 return -EINVAL;
2595 }
2596
2597 /* (un)blank/poweroff
2598 * 0 = unblank
2599 * 1 = blank
2600 * 2 = suspend vsync
2601 * 3 = suspend hsync
2602 * 4 = off
2603 */
2604 static int
2605 atafb_blank(int blank, struct fb_info *info)
2606 {
2607 unsigned short black[16];
2608 struct fb_cmap cmap;
2609 if (fbhw->blank && !fbhw->blank(blank))
2610 return 1;
2611 if (blank) {
2612 memset(black, 0, 16*sizeof(unsigned short));
2613 cmap.red=black;
2614 cmap.green=black;
2615 cmap.blue=black;
2616 cmap.transp=NULL;
2617 cmap.start=0;
2618 cmap.len=16;
2619 fb_set_cmap(&cmap, 1, info);
2620 }
2621 else
2622 do_install_cmap(info->currcon, info);
2623 return 0;
2624 }
2625
2626 static struct fb_ops atafb_ops = {
2627 .owner = THIS_MODULE,
2628 .fb_get_fix = atafb_get_fix,
2629 .fb_get_var = atafb_get_var,
2630 .fb_set_var = atafb_set_var,
2631 .fb_get_cmap = atafb_get_cmap,
2632 .fb_set_cmap = gen_set_cmap,
2633 .fb_pan_display =atafb_pan_display,
2634 .fb_blank = atafb_blank,
2635 .fb_ioctl = atafb_ioctl,
2636 };
2637
2638 static void
2639 check_default_par( int detected_mode )
2640 {
2641 char default_name[10];
2642 int i;
2643 struct fb_var_screeninfo var;
2644 unsigned long min_mem;
2645
2646 /* First try the user supplied mode */
2647 if (default_par) {
2648 var=atafb_predefined[default_par-1];
2649 var.activate = FB_ACTIVATE_TEST;
2650 if (do_fb_set_var(&var,1))
2651 default_par=0; /* failed */
2652 }
2653 /* Next is the autodetected one */
2654 if (! default_par) {
2655 var=atafb_predefined[detected_mode-1]; /* autodetect */
2656 var.activate = FB_ACTIVATE_TEST;
2657 if (!do_fb_set_var(&var,1))
2658 default_par=detected_mode;
2659 }
2660 /* If that also failed, try some default modes... */
2661 if (! default_par) {
2662 /* try default1, default2... */
2663 for (i=1 ; i < 10 ; i++) {
2664 sprintf(default_name,"default%d",i);
2665 default_par=get_video_mode(default_name);
2666 if (! default_par)
2667 panic("can't set default video mode");
2668 var=atafb_predefined[default_par-1];
2669 var.activate = FB_ACTIVATE_TEST;
2670 if (! do_fb_set_var(&var,1))
2671 break; /* ok */
2672 }
2673 }
2674 min_mem=var.xres_virtual * var.yres_virtual * var.bits_per_pixel/8;
2675 if (default_mem_req < min_mem)
2676 default_mem_req=min_mem;
2677 }
2678
2679 static int
2680 atafb_switch(int con, struct fb_info *info)
2681 {
2682 /* Do we have to save the colormap ? */
2683 if (fb_display[info->currcon].cmap.len)
2684 fb_get_cmap(&fb_display[info->currcon].cmap, 1, fbhw->getcolreg,
2685 info);
2686 do_fb_set_var(&fb_display[con].var,1);
2687 info->currcon=con;
2688 /* Install new colormap */
2689 do_install_cmap(con, info);
2690 return 0;
2691 }
2692
2693 int __init atafb_init(void)
2694 {
2695 int pad;
2696 int detected_mode;
2697 unsigned long mem_req;
2698
2699 if (!MACH_IS_ATARI)
2700 return -ENXIO;
2701
2702 do {
2703 #ifdef ATAFB_EXT
2704 if (external_addr) {
2705 fbhw = &ext_switch;
2706 atafb_ops.fb_setcolreg = &ext_setcolreg;
2707 break;
2708 }
2709 #endif
2710 #ifdef ATAFB_TT
2711 if (ATARIHW_PRESENT(TT_SHIFTER)) {
2712 fbhw = &tt_switch;
2713 atafb_ops.fb_setcolreg = &tt_setcolreg;
2714 break;
2715 }
2716 #endif
2717 #ifdef ATAFB_FALCON
2718 if (ATARIHW_PRESENT(VIDEL_SHIFTER)) {
2719 fbhw = &falcon_switch;
2720 atafb_ops.fb_setcolreg = &falcon_setcolreg;
2721 request_irq(IRQ_AUTO_4, falcon_vbl_switcher, IRQ_TYPE_PRIO,
2722 "framebuffer/modeswitch", falcon_vbl_switcher);
2723 break;
2724 }
2725 #endif
2726 #ifdef ATAFB_STE
2727 if (ATARIHW_PRESENT(STND_SHIFTER) ||
2728 ATARIHW_PRESENT(EXTD_SHIFTER)) {
2729 fbhw = &st_switch;
2730 atafb_ops.fb_setcolreg = &stste_setcolreg;
2731 break;
2732 }
2733 fbhw = &st_switch;
2734 atafb_ops.fb_setcolreg = &stste_setcolreg;
2735 printk("Cannot determine video hardware; defaulting to ST(e)\n");
2736 #else /* ATAFB_STE */
2737 /* no default driver included */
2738 /* Nobody will ever see this message :-) */
2739 panic("Cannot initialize video hardware");
2740 #endif
2741 } while (0);
2742
2743 /* Multisync monitor capabilities */
2744 /* Atari-TOS defaults if no boot option present */
2745 if (fb_info.monspecs.hfmin == 0) {
2746 fb_info.monspecs.hfmin = 31000;
2747 fb_info.monspecs.hfmax = 32000;
2748 fb_info.monspecs.vfmin = 58;
2749 fb_info.monspecs.vfmax = 62;
2750 }
2751
2752 detected_mode = fbhw->detect();
2753 check_default_par(detected_mode);
2754 #ifdef ATAFB_EXT
2755 if (!external_addr) {
2756 #endif /* ATAFB_EXT */
2757 mem_req = default_mem_req + ovsc_offset + ovsc_addlen;
2758 mem_req = PAGE_ALIGN(mem_req) + PAGE_SIZE;
2759 screen_base = atari_stram_alloc(mem_req, "atafb");
2760 if (!screen_base)
2761 panic("Cannot allocate screen memory");
2762 memset(screen_base, 0, mem_req);
2763 pad = -(unsigned long)screen_base & (PAGE_SIZE-1);
2764 screen_base+=pad;
2765 real_screen_base=screen_base+ovsc_offset;
2766 screen_len = (mem_req - pad - ovsc_offset) & PAGE_MASK;
2767 st_ovsc_switch();
2768 if (CPU_IS_040_OR_060) {
2769 /* On a '040+, the cache mode of video RAM must be set to
2770 * write-through also for internal video hardware! */
2771 cache_push(virt_to_phys(screen_base), screen_len);
2772 kernel_set_cachemode(screen_base, screen_len,
2773 IOMAP_WRITETHROUGH);
2774 }
2775 #ifdef ATAFB_EXT
2776 }
2777 else {
2778 /* Map the video memory (physical address given) to somewhere
2779 * in the kernel address space.
2780 */
2781 external_addr =
2782 ioremap_writethrough((unsigned long)external_addr,
2783 external_len);
2784 if (external_vgaiobase)
2785 external_vgaiobase =
2786 (unsigned long)ioremap(external_vgaiobase, 0x10000);
2787 screen_base =
2788 real_screen_base = external_addr;
2789 screen_len = external_len & PAGE_MASK;
2790 memset (screen_base, 0, external_len);
2791 }
2792 #endif /* ATAFB_EXT */
2793
2794 strcpy(fb_info.modename, "Atari Builtin ");
2795 fb_info.changevar = NULL;
2796 fb_info.fbops = &atafb_ops;
2797 fb_info.disp = &disp;
2798 fb_info.currcon = -1;
2799 fb_info.switch_con = &atafb_switch;
2800 fb_info.updatevar = &fb_update_var;
2801 fb_info.flags = FBINFO_FLAG_DEFAULT;
2802 do_fb_set_var(&atafb_predefined[default_par-1], 1);
2803 strcat(fb_info.modename, fb_var_names[default_par-1][0]);
2804
2805 atafb_get_var(&disp.var, -1, &fb_info);
2806 atafb_set_disp(-1, &fb_info);
2807 do_install_cmap(0, &fb_info);
2808
2809 if (register_framebuffer(&fb_info) < 0)
2810 return -EINVAL;
2811
2812 printk("Determined %dx%d, depth %d\n",
2813 disp.var.xres, disp.var.yres, disp.var.bits_per_pixel);
2814 if ((disp.var.xres != disp.var.xres_virtual) ||
2815 (disp.var.yres != disp.var.yres_virtual))
2816 printk(" virtual %dx%d\n",
2817 disp.var.xres_virtual, disp.var.yres_virtual);
2818 printk("fb%d: %s frame buffer device, using %dK of video memory\n",
2819 fb_info.node, fb_info.modename, screen_len>>10);
2820
2821 /* TODO: This driver cannot be unloaded yet */
2822 return 0;
2823 }
2824
2825
2826 #ifdef ATAFB_EXT
2827 static void __init atafb_setup_ext(char *spec)
2828 {
2829 int xres, xres_virtual, yres, depth, planes;
2830 unsigned long addr, len;
2831 char *p;
2832
2833 /* Format is: <xres>;<yres>;<depth>;<plane organ.>;
2834 * <screen mem addr>
2835 * [;<screen mem length>[;<vgaiobase>[;<bits-per-col>[;<colorreg-type>
2836 * [;<xres-virtual>]]]]]
2837 *
2838 * 09/23/97 Juergen
2839 * <xres_virtual>: hardware's x-resolution (f.e. ProMST)
2840 *
2841 * Even xres_virtual is available, we neither support panning nor hw-scrolling!
2842 */
2843 if (!(p = strsep(&spec, ";")) || !*p)
2844 return;
2845 xres_virtual = xres = simple_strtoul(p, NULL, 10);
2846 if (xres <= 0)
2847 return;
2848
2849 if (!(p = strsep(&spec, ";")) || !*p)
2850 return;
2851 yres = simple_strtoul(p, NULL, 10);
2852 if (yres <= 0)
2853 return;
2854
2855 if (!(p = strsep(&spec, ";")) || !*p)
2856 return;
2857 depth = simple_strtoul(p, NULL, 10);
2858 if (depth != 1 && depth != 2 && depth != 4 && depth != 8 &&
2859 depth != 16 && depth != 24)
2860 return;
2861
2862 if (!(p = strsep(&spec, ";")) || !*p)
2863 return;
2864 if (*p == 'i')
2865 planes = FB_TYPE_INTERLEAVED_PLANES;
2866 else if (*p == 'p')
2867 planes = FB_TYPE_PACKED_PIXELS;
2868 else if (*p == 'n')
2869 planes = FB_TYPE_PLANES;
2870 else if (*p == 't')
2871 planes = -1; /* true color */
2872 else
2873 return;
2874
2875
2876 if (!(p = strsep(&spec, ";")) || !*p)
2877 return;
2878 addr = simple_strtoul(p, NULL, 0);
2879
2880 if (!(p = strsep(&spec, ";")) || !*p)
2881 len = xres*yres*depth/8;
2882 else
2883 len = simple_strtoul(p, NULL, 0);
2884
2885 if ((p = strsep(&spec, ";")) && *p) {
2886 external_vgaiobase=simple_strtoul(p, NULL, 0);
2887 }
2888
2889 if ((p = strsep(&spec, ";")) && *p) {
2890 external_bitspercol = simple_strtoul(p, NULL, 0);
2891 if (external_bitspercol > 8)
2892 external_bitspercol = 8;
2893 else if (external_bitspercol < 1)
2894 external_bitspercol = 1;
2895 }
2896
2897 if ((p = strsep(&spec, ";")) && *p) {
2898 if (!strcmp(p, "vga"))
2899 external_card_type = IS_VGA;
2900 if (!strcmp(p, "mv300"))
2901 external_card_type = IS_MV300;
2902 }
2903
2904 if ((p = strsep(&spec, ";")) && *p) {
2905 xres_virtual = simple_strtoul(p, NULL, 10);
2906 if (xres_virtual < xres)
2907 xres_virtual = xres;
2908 if (xres_virtual*yres*depth/8 > len)
2909 len=xres_virtual*yres*depth/8;
2910 }
2911
2912 external_xres = xres;
2913 external_xres_virtual = xres_virtual;
2914 external_yres = yres;
2915 external_depth = depth;
2916 external_pmode = planes;
2917 external_addr = (void *)addr;
2918 external_len = len;
2919
2920 if (external_card_type == IS_MV300)
2921 switch (external_depth) {
2922 case 1:
2923 MV300_reg = MV300_reg_1bit;
2924 break;
2925 case 4:
2926 MV300_reg = MV300_reg_4bit;
2927 break;
2928 case 8:
2929 MV300_reg = MV300_reg_8bit;
2930 break;
2931 }
2932 }
2933 #endif /* ATAFB_EXT */
2934
2935
2936 static void __init atafb_setup_int(char *spec)
2937 {
2938 /* Format to config extended internal video hardware like OverScan:
2939 "internal:<xres>;<yres>;<xres_max>;<yres_max>;<offset>"
2940 Explanation:
2941 <xres>: x-resolution
2942 <yres>: y-resolution
2943 The following are only needed if you have an overscan which
2944 needs a black border:
2945 <xres_max>: max. length of a line in pixels your OverScan hardware would allow
2946 <yres_max>: max. number of lines your OverScan hardware would allow
2947 <offset>: Offset from physical beginning to visible beginning
2948 of screen in bytes
2949 */
2950 int xres;
2951 char *p;
2952
2953 if (!(p = strsep(&spec, ";")) || !*p)
2954 return;
2955 xres = simple_strtoul(p, NULL, 10);
2956 if (!(p = strsep(&spec, ";")) || !*p)
2957 return;
2958 sttt_xres=xres;
2959 tt_yres=st_yres=simple_strtoul(p, NULL, 10);
2960 if ((p=strsep(&spec, ";")) && *p) {
2961 sttt_xres_virtual=simple_strtoul(p, NULL, 10);
2962 }
2963 if ((p=strsep(&spec, ";")) && *p) {
2964 sttt_yres_virtual=simple_strtoul(p, NULL, 0);
2965 }
2966 if ((p=strsep(&spec, ";")) && *p) {
2967 ovsc_offset=simple_strtoul(p, NULL, 0);
2968 }
2969
2970 if (ovsc_offset || (sttt_yres_virtual != st_yres))
2971 use_hwscroll=0;
2972 }
2973
2974
2975 #ifdef ATAFB_FALCON
2976 static void __init atafb_setup_mcap(char *spec)
2977 {
2978 char *p;
2979 int vmin, vmax, hmin, hmax;
2980
2981 /* Format for monitor capabilities is: <Vmin>;<Vmax>;<Hmin>;<Hmax>
2982 * <V*> vertical freq. in Hz
2983 * <H*> horizontal freq. in kHz
2984 */
2985 if (!(p = strsep(&spec, ";")) || !*p)
2986 return;
2987 vmin = simple_strtoul(p, NULL, 10);
2988 if (vmin <= 0)
2989 return;
2990 if (!(p = strsep(&spec, ";")) || !*p)
2991 return;
2992 vmax = simple_strtoul(p, NULL, 10);
2993 if (vmax <= 0 || vmax <= vmin)
2994 return;
2995 if (!(p = strsep(&spec, ";")) || !*p)
2996 return;
2997 hmin = 1000 * simple_strtoul(p, NULL, 10);
2998 if (hmin <= 0)
2999 return;
3000 if (!(p = strsep(&spec, "")) || !*p)
3001 return;
3002 hmax = 1000 * simple_strtoul(p, NULL, 10);
3003 if (hmax <= 0 || hmax <= hmin)
3004 return;
3005
3006 fb_info.monspecs.vfmin = vmin;
3007 fb_info.monspecs.vfmax = vmax;
3008 fb_info.monspecs.hfmin = hmin;
3009 fb_info.monspecs.hfmax = hmax;
3010 }
3011 #endif /* ATAFB_FALCON */
3012
3013
3014 static void __init atafb_setup_user(char *spec)
3015 {
3016 /* Format of user defined video mode is: <xres>;<yres>;<depth>
3017 */
3018 char *p;
3019 int xres, yres, depth, temp;
3020
3021 if (!(p = strsep(&spec, ";")) || !*p)
3022 return;
3023 xres = simple_strtoul(p, NULL, 10);
3024 if (!(p = strsep(&spec, ";")) || !*p)
3025 return;
3026 yres = simple_strtoul(p, NULL, 10);
3027 if (!(p = strsep(&spec, "")) || !*p)
3028 return;
3029 depth = simple_strtoul(p, NULL, 10);
3030 if ((temp=get_video_mode("user0"))) {
3031 default_par=temp;
3032 atafb_predefined[default_par-1].xres = xres;
3033 atafb_predefined[default_par-1].yres = yres;
3034 atafb_predefined[default_par-1].bits_per_pixel = depth;
3035 }
3036 }
3037
3038 int __init atafb_setup( char *options )
3039 {
3040 char *this_opt;
3041 int temp;
3042
3043 fb_info.fontname[0] = '\0';
3044
3045 if (!options || !*options)
3046 return 0;
3047
3048 while ((this_opt = strsep(&options, ",")) != NULL) {
3049 if (!*this_opt) continue;
3050 if ((temp=get_video_mode(this_opt)))
3051 default_par=temp;
3052 else if (! strcmp(this_opt, "inverse"))
3053 inverse=1;
3054 else if (!strncmp(this_opt, "font:", 5))
3055 strcpy(fb_info.fontname, this_opt+5);
3056 else if (! strncmp(this_opt, "hwscroll_",9)) {
3057 hwscroll=simple_strtoul(this_opt+9, NULL, 10);
3058 if (hwscroll < 0)
3059 hwscroll = 0;
3060 if (hwscroll > 200)
3061 hwscroll = 200;
3062 }
3063 #ifdef ATAFB_EXT
3064 else if (!strcmp(this_opt,"mv300")) {
3065 external_bitspercol = 8;
3066 external_card_type = IS_MV300;
3067 }
3068 else if (!strncmp(this_opt,"external:",9))
3069 atafb_setup_ext(this_opt+9);
3070 #endif
3071 else if (!strncmp(this_opt,"internal:",9))
3072 atafb_setup_int(this_opt+9);
3073 #ifdef ATAFB_FALCON
3074 else if (!strncmp(this_opt, "eclock:", 7)) {
3075 fext.f = simple_strtoul(this_opt+7, NULL, 10);
3076 /* external pixelclock in kHz --> ps */
3077 fext.t = 1000000000/fext.f;
3078 fext.f *= 1000;
3079 }
3080 else if (!strncmp(this_opt, "monitorcap:", 11))
3081 atafb_setup_mcap(this_opt+11);
3082 #endif
3083 else if (!strcmp(this_opt, "keep"))
3084 DontCalcRes = 1;
3085 else if (!strncmp(this_opt, "R", 1))
3086 atafb_setup_user(this_opt+1);
3087 }
3088 return 0;
3089 }
3090
3091 #ifdef MODULE
3092 MODULE_LICENSE("GPL");
3093
3094 int init_module(void)
3095 {
3096 return atafb_init();
3097 }
3098 #endif /* MODULE */
Verdex Pro support