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