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