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