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