?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] W1: w1_netlink: New init/fini netlink callbacks.
[linux-2.6/verdex.git] / drivers / video / amifb.c
blobcf8bb67462dc59de02088f46429a134052d8b53a
1 /*
2 * linux/drivers/video/amifb.c -- Amiga builtin chipset frame buffer device
3 *
4 * Copyright (C) 1995-2003 Geert Uytterhoeven
5 *
6 * with work by Roman Zippel
7 *
8 *
9 * This file is based on the Atari frame buffer device (atafb.c):
10 *
11 * Copyright (C) 1994 Martin Schaller
12 * Roman Hodek
13 *
14 * with work by Andreas Schwab
15 * Guenther Kelleter
16 *
17 * and on the original Amiga console driver (amicon.c):
18 *
19 * Copyright (C) 1993 Hamish Macdonald
20 * Greg Harp
21 * Copyright (C) 1994 David Carter [carter@compsci.bristol.ac.uk]
22 *
23 * with work by William Rucklidge (wjr@cs.cornell.edu)
24 * Geert Uytterhoeven
25 * Jes Sorensen (jds@kom.auc.dk)
26 *
27 *
28 * History:
29 *
30 * - 24 Jul 96: Copper generates now vblank interrupt and
31 * VESA Power Saving Protocol is fully implemented
32 * - 14 Jul 96: Rework and hopefully last ECS bugs fixed
33 * - 7 Mar 96: Hardware sprite support by Roman Zippel
34 * - 18 Feb 96: OCS and ECS support by Roman Zippel
35 * Hardware functions completely rewritten
36 * - 2 Dec 95: AGA version by Geert Uytterhoeven
37 *
38 * This file is subject to the terms and conditions of the GNU General Public
39 * License. See the file COPYING in the main directory of this archive
40 * for more details.
41 */
42
43 #include <linux/module.h>
44 #include <linux/kernel.h>
45 #include <linux/errno.h>
46 #include <linux/string.h>
47 #include <linux/mm.h>
48 #include <linux/tty.h>
49 #include <linux/slab.h>
50 #include <linux/delay.h>
51 #include <linux/config.h>
52 #include <linux/interrupt.h>
53 #include <linux/fb.h>
54 #include <linux/init.h>
55 #include <linux/ioport.h>
56
57 #include <asm/uaccess.h>
58 #include <asm/system.h>
59 #include <asm/irq.h>
60 #include <asm/amigahw.h>
61 #include <asm/amigaints.h>
62 #include <asm/setup.h>
63
64 #include "c2p.h"
65
66
67 #define DEBUG
68
69 #if !defined(CONFIG_FB_AMIGA_OCS) && !defined(CONFIG_FB_AMIGA_ECS) && !defined(CONFIG_FB_AMIGA_AGA)
70 #define CONFIG_FB_AMIGA_OCS /* define at least one fb driver, this will change later */
71 #endif
72
73 #if !defined(CONFIG_FB_AMIGA_OCS)
74 # define IS_OCS (0)
75 #elif defined(CONFIG_FB_AMIGA_ECS) || defined(CONFIG_FB_AMIGA_AGA)
76 # define IS_OCS (chipset == TAG_OCS)
77 #else
78 # define CONFIG_FB_AMIGA_OCS_ONLY
79 # define IS_OCS (1)
80 #endif
81
82 #if !defined(CONFIG_FB_AMIGA_ECS)
83 # define IS_ECS (0)
84 #elif defined(CONFIG_FB_AMIGA_OCS) || defined(CONFIG_FB_AMIGA_AGA)
85 # define IS_ECS (chipset == TAG_ECS)
86 #else
87 # define CONFIG_FB_AMIGA_ECS_ONLY
88 # define IS_ECS (1)
89 #endif
90
91 #if !defined(CONFIG_FB_AMIGA_AGA)
92 # define IS_AGA (0)
93 #elif defined(CONFIG_FB_AMIGA_OCS) || defined(CONFIG_FB_AMIGA_ECS)
94 # define IS_AGA (chipset == TAG_AGA)
95 #else
96 # define CONFIG_FB_AMIGA_AGA_ONLY
97 # define IS_AGA (1)
98 #endif
99
100 #ifdef DEBUG
101 # define DPRINTK(fmt, args...) printk(KERN_DEBUG "%s: " fmt, __FUNCTION__ , ## args)
102 #else
103 # define DPRINTK(fmt, args...)
104 #endif
105
106 /*******************************************************************************
107
108
109 Generic video timings
110 ---------------------
111
112 Timings used by the frame buffer interface:
113
114 +----------+---------------------------------------------+----------+-------+
115 | | ^ | | |
116 | | |upper_margin | | |
117 | | ¥ | | |
118 +----------###############################################----------+-------+
119 | # ^ # | |
120 | # | # | |
121 | # | # | |
122 | # | # | |
123 | left # | # right | hsync |
124 | margin # | xres # margin | len |
125 |<-------->#<---------------+--------------------------->#<-------->|<----->|
126 | # | # | |
127 | # | # | |
128 | # | # | |
129 | # |yres # | |
130 | # | # | |
131 | # | # | |
132 | # | # | |
133 | # | # | |
134 | # | # | |
135 | # | # | |
136 | # | # | |
137 | # | # | |
138 | # ¥ # | |
139 +----------###############################################----------+-------+
140 | | ^ | | |
141 | | |lower_margin | | |
142 | | ¥ | | |
143 +----------+---------------------------------------------+----------+-------+
144 | | ^ | | |
145 | | |vsync_len | | |
146 | | ¥ | | |
147 +----------+---------------------------------------------+----------+-------+
148
149
150 Amiga video timings
151 -------------------
152
153 The Amiga native chipsets uses another timing scheme:
154
155 - hsstrt: Start of horizontal synchronization pulse
156 - hsstop: End of horizontal synchronization pulse
157 - htotal: Last value on the line (i.e. line length = htotal+1)
158 - vsstrt: Start of vertical synchronization pulse
159 - vsstop: End of vertical synchronization pulse
160 - vtotal: Last line value (i.e. number of lines = vtotal+1)
161 - hcenter: Start of vertical retrace for interlace
162
163 You can specify the blanking timings independently. Currently I just set
164 them equal to the respective synchronization values:
165
166 - hbstrt: Start of horizontal blank
167 - hbstop: End of horizontal blank
168 - vbstrt: Start of vertical blank
169 - vbstop: End of vertical blank
170
171 Horizontal values are in color clock cycles (280 ns), vertical values are in
172 scanlines.
173
174 (0, 0) is somewhere in the upper-left corner :-)
175
176
177 Amiga visible window definitions
178 --------------------------------
179
180 Currently I only have values for AGA, SHRES (28 MHz dotclock). Feel free to
181 make corrections and/or additions.
182
183 Within the above synchronization specifications, the visible window is
184 defined by the following parameters (actual register resolutions may be
185 different; all horizontal values are normalized with respect to the pixel
186 clock):
187
188 - diwstrt_h: Horizontal start of the visible window
189 - diwstop_h: Horizontal stop+1(*) of the visible window
190 - diwstrt_v: Vertical start of the visible window
191 - diwstop_v: Vertical stop of the visible window
192 - ddfstrt: Horizontal start of display DMA
193 - ddfstop: Horizontal stop of display DMA
194 - hscroll: Horizontal display output delay
195
196 Sprite positioning:
197
198 - sprstrt_h: Horizontal start-4 of sprite
199 - sprstrt_v: Vertical start of sprite
200
201 (*) Even Commodore did it wrong in the AGA monitor drivers by not adding 1.
202
203 Horizontal values are in dotclock cycles (35 ns), vertical values are in
204 scanlines.
205
206 (0, 0) is somewhere in the upper-left corner :-)
207
208
209 Dependencies (AGA, SHRES (35 ns dotclock))
210 -------------------------------------------
211
212 Since there are much more parameters for the Amiga display than for the
213 frame buffer interface, there must be some dependencies among the Amiga
214 display parameters. Here's what I found out:
215
216 - ddfstrt and ddfstop are best aligned to 64 pixels.
217 - the chipset needs 64+4 horizontal pixels after the DMA start before the
218 first pixel is output, so diwstrt_h = ddfstrt+64+4 if you want to
219 display the first pixel on the line too. Increase diwstrt_h for virtual
220 screen panning.
221 - the display DMA always fetches 64 pixels at a time (fmode = 3).
222 - ddfstop is ddfstrt+#pixels-64.
223 - diwstop_h = diwstrt_h+xres+1. Because of the additional 1 this can be 1
224 more than htotal.
225 - hscroll simply adds a delay to the display output. Smooth horizontal
226 panning needs an extra 64 pixels on the left to prefetch the pixels that
227 `fall off' on the left.
228 - if ddfstrt < 192, the sprite DMA cycles are all stolen by the bitplane
229 DMA, so it's best to make the DMA start as late as possible.
230 - you really don't want to make ddfstrt < 128, since this will steal DMA
231 cycles from the other DMA channels (audio, floppy and Chip RAM refresh).
232 - I make diwstop_h and diwstop_v as large as possible.
233
234 General dependencies
235 --------------------
236
237 - all values are SHRES pixel (35ns)
238
239 table 1:fetchstart table 2:prefetch table 3:fetchsize
240 ------------------ ---------------- -----------------
241 Pixclock # SHRES|HIRES|LORES # SHRES|HIRES|LORES # SHRES|HIRES|LORES
242 -------------#------+-----+------#------+-----+------#------+-----+------
243 Bus width 1x # 16 | 32 | 64 # 16 | 32 | 64 # 64 | 64 | 64
244 Bus width 2x # 32 | 64 | 128 # 32 | 64 | 64 # 64 | 64 | 128
245 Bus width 4x # 64 | 128 | 256 # 64 | 64 | 64 # 64 | 128 | 256
246
247 - chipset needs 4 pixels before the first pixel is output
248 - ddfstrt must be aligned to fetchstart (table 1)
249 - chipset needs also prefetch (table 2) to get first pixel data, so
250 ddfstrt = ((diwstrt_h-4) & -fetchstart) - prefetch
251 - for horizontal panning decrease diwstrt_h
252 - the length of a fetchline must be aligned to fetchsize (table 3)
253 - if fetchstart is smaller than fetchsize, then ddfstrt can a little bit
254 moved to optimize use of dma (useful for OCS/ECS overscan displays)
255 - ddfstop is ddfstrt+ddfsize-fetchsize
256 - If C= didn't change anything for AGA, then at following positions the
257 dma bus is already used:
258 ddfstrt < 48 -> memory refresh
259 < 96 -> disk dma
260 < 160 -> audio dma
261 < 192 -> sprite 0 dma
262 < 416 -> sprite dma (32 per sprite)
263 - in accordance with the hardware reference manual a hardware stop is at
264 192, but AGA (ECS?) can go below this.
265
266 DMA priorities
267 --------------
268
269 Since there are limits on the earliest start value for display DMA and the
270 display of sprites, I use the following policy on horizontal panning and
271 the hardware cursor:
272
273 - if you want to start display DMA too early, you lose the ability to
274 do smooth horizontal panning (xpanstep 1 -> 64).
275 - if you want to go even further, you lose the hardware cursor too.
276
277 IMHO a hardware cursor is more important for X than horizontal scrolling,
278 so that's my motivation.
279
280
281 Implementation
282 --------------
283
284 ami_decode_var() converts the frame buffer values to the Amiga values. It's
285 just a `straightforward' implementation of the above rules.
286
287
288 Standard VGA timings
289 --------------------
290
291 xres yres left right upper lower hsync vsync
292 ---- ---- ---- ----- ----- ----- ----- -----
293 80x25 720 400 27 45 35 12 108 2
294 80x30 720 480 27 45 30 9 108 2
295
296 These were taken from a XFree86 configuration file, recalculated for a 28 MHz
297 dotclock (Amigas don't have a 25 MHz dotclock) and converted to frame buffer
298 generic timings.
299
300 As a comparison, graphics/monitor.h suggests the following:
301
302 xres yres left right upper lower hsync vsync
303 ---- ---- ---- ----- ----- ----- ----- -----
304
305 VGA 640 480 52 112 24 19 112 - 2 +
306 VGA70 640 400 52 112 27 21 112 - 2 -
307
308
309 Sync polarities
310 ---------------
311
312 VSYNC HSYNC Vertical size Vertical total
313 ----- ----- ------------- --------------
314 + + Reserved Reserved
315 + - 400 414
316 - + 350 362
317 - - 480 496
318
319 Source: CL-GD542X Technical Reference Manual, Cirrus Logic, Oct 1992
320
321
322 Broadcast video timings
323 -----------------------
324
325 According to the CCIR and RETMA specifications, we have the following values:
326
327 CCIR -> PAL
328 -----------
329
330 - a scanline is 64 µs long, of which 52.48 µs are visible. This is about
331 736 visible 70 ns pixels per line.
332 - we have 625 scanlines, of which 575 are visible (interlaced); after
333 rounding this becomes 576.
334
335 RETMA -> NTSC
336 -------------
337
338 - a scanline is 63.5 µs long, of which 53.5 µs are visible. This is about
339 736 visible 70 ns pixels per line.
340 - we have 525 scanlines, of which 485 are visible (interlaced); after
341 rounding this becomes 484.
342
343 Thus if you want a PAL compatible display, you have to do the following:
344
345 - set the FB_SYNC_BROADCAST flag to indicate that standard broadcast
346 timings are to be used.
347 - make sure upper_margin+yres+lower_margin+vsync_len = 625 for an
348 interlaced, 312 for a non-interlaced and 156 for a doublescanned
349 display.
350 - make sure left_margin+xres+right_margin+hsync_len = 1816 for a SHRES,
351 908 for a HIRES and 454 for a LORES display.
352 - the left visible part begins at 360 (SHRES; HIRES:180, LORES:90),
353 left_margin+2*hsync_len must be greater or equal.
354 - the upper visible part begins at 48 (interlaced; non-interlaced:24,
355 doublescanned:12), upper_margin+2*vsync_len must be greater or equal.
356 - ami_encode_var() calculates margins with a hsync of 5320 ns and a vsync
357 of 4 scanlines
358
359 The settings for a NTSC compatible display are straightforward.
360
361 Note that in a strict sense the PAL and NTSC standards only define the
362 encoding of the color part (chrominance) of the video signal and don't say
363 anything about horizontal/vertical synchronization nor refresh rates.
364
365
366 -- Geert --
367
368 *******************************************************************************/
369
370
371 /*
372 * Custom Chipset Definitions
373 */
374
375 #define CUSTOM_OFS(fld) ((long)&((struct CUSTOM*)0)->fld)
376
377 /*
378 * BPLCON0 -- Bitplane Control Register 0
379 */
380
381 #define BPC0_HIRES (0x8000)
382 #define BPC0_BPU2 (0x4000) /* Bit plane used count */
383 #define BPC0_BPU1 (0x2000)
384 #define BPC0_BPU0 (0x1000)
385 #define BPC0_HAM (0x0800) /* HAM mode */
386 #define BPC0_DPF (0x0400) /* Double playfield */
387 #define BPC0_COLOR (0x0200) /* Enable colorburst */
388 #define BPC0_GAUD (0x0100) /* Genlock audio enable */
389 #define BPC0_UHRES (0x0080) /* Ultrahi res enable */
390 #define BPC0_SHRES (0x0040) /* Super hi res mode */
391 #define BPC0_BYPASS (0x0020) /* Bypass LUT - AGA */
392 #define BPC0_BPU3 (0x0010) /* AGA */
393 #define BPC0_LPEN (0x0008) /* Light pen enable */
394 #define BPC0_LACE (0x0004) /* Interlace */
395 #define BPC0_ERSY (0x0002) /* External resync */
396 #define BPC0_ECSENA (0x0001) /* ECS enable */
397
398 /*
399 * BPLCON2 -- Bitplane Control Register 2
400 */
401
402 #define BPC2_ZDBPSEL2 (0x4000) /* Bitplane to be used for ZD - AGA */
403 #define BPC2_ZDBPSEL1 (0x2000)
404 #define BPC2_ZDBPSEL0 (0x1000)
405 #define BPC2_ZDBPEN (0x0800) /* Enable ZD with ZDBPSELx - AGA */
406 #define BPC2_ZDCTEN (0x0400) /* Enable ZD with palette bit #31 - AGA */
407 #define BPC2_KILLEHB (0x0200) /* Kill EHB mode - AGA */
408 #define BPC2_RDRAM (0x0100) /* Color table accesses read, not write - AGA */
409 #define BPC2_SOGEN (0x0080) /* SOG output pin high - AGA */
410 #define BPC2_PF2PRI (0x0040) /* PF2 priority over PF1 */
411 #define BPC2_PF2P2 (0x0020) /* PF2 priority wrt sprites */
412 #define BPC2_PF2P1 (0x0010)
413 #define BPC2_PF2P0 (0x0008)
414 #define BPC2_PF1P2 (0x0004) /* ditto PF1 */
415 #define BPC2_PF1P1 (0x0002)
416 #define BPC2_PF1P0 (0x0001)
417
418 /*
419 * BPLCON3 -- Bitplane Control Register 3 (AGA)
420 */
421
422 #define BPC3_BANK2 (0x8000) /* Bits to select color register bank */
423 #define BPC3_BANK1 (0x4000)
424 #define BPC3_BANK0 (0x2000)
425 #define BPC3_PF2OF2 (0x1000) /* Bits for color table offset when PF2 */
426 #define BPC3_PF2OF1 (0x0800)
427 #define BPC3_PF2OF0 (0x0400)
428 #define BPC3_LOCT (0x0200) /* Color register writes go to low bits */
429 #define BPC3_SPRES1 (0x0080) /* Sprite resolution bits */
430 #define BPC3_SPRES0 (0x0040)
431 #define BPC3_BRDRBLNK (0x0020) /* Border blanked? */
432 #define BPC3_BRDRTRAN (0x0010) /* Border transparent? */
433 #define BPC3_ZDCLKEN (0x0004) /* ZD pin is 14 MHz (HIRES) clock output */
434 #define BPC3_BRDRSPRT (0x0002) /* Sprites in border? */
435 #define BPC3_EXTBLKEN (0x0001) /* BLANK programmable */
436
437 /*
438 * BPLCON4 -- Bitplane Control Register 4 (AGA)
439 */
440
441 #define BPC4_BPLAM7 (0x8000) /* bitplane color XOR field */
442 #define BPC4_BPLAM6 (0x4000)
443 #define BPC4_BPLAM5 (0x2000)
444 #define BPC4_BPLAM4 (0x1000)
445 #define BPC4_BPLAM3 (0x0800)
446 #define BPC4_BPLAM2 (0x0400)
447 #define BPC4_BPLAM1 (0x0200)
448 #define BPC4_BPLAM0 (0x0100)
449 #define BPC4_ESPRM7 (0x0080) /* 4 high bits for even sprite colors */
450 #define BPC4_ESPRM6 (0x0040)
451 #define BPC4_ESPRM5 (0x0020)
452 #define BPC4_ESPRM4 (0x0010)
453 #define BPC4_OSPRM7 (0x0008) /* 4 high bits for odd sprite colors */
454 #define BPC4_OSPRM6 (0x0004)
455 #define BPC4_OSPRM5 (0x0002)
456 #define BPC4_OSPRM4 (0x0001)
457
458 /*
459 * BEAMCON0 -- Beam Control Register
460 */
461
462 #define BMC0_HARDDIS (0x4000) /* Disable hardware limits */
463 #define BMC0_LPENDIS (0x2000) /* Disable light pen latch */
464 #define BMC0_VARVBEN (0x1000) /* Enable variable vertical blank */
465 #define BMC0_LOLDIS (0x0800) /* Disable long/short line toggle */
466 #define BMC0_CSCBEN (0x0400) /* Composite sync/blank */
467 #define BMC0_VARVSYEN (0x0200) /* Enable variable vertical sync */
468 #define BMC0_VARHSYEN (0x0100) /* Enable variable horizontal sync */
469 #define BMC0_VARBEAMEN (0x0080) /* Enable variable beam counters */
470 #define BMC0_DUAL (0x0040) /* Enable alternate horizontal beam counter */
471 #define BMC0_PAL (0x0020) /* Set decodes for PAL */
472 #define BMC0_VARCSYEN (0x0010) /* Enable variable composite sync */
473 #define BMC0_BLANKEN (0x0008) /* Blank enable (no longer used on AGA) */
474 #define BMC0_CSYTRUE (0x0004) /* CSY polarity */
475 #define BMC0_VSYTRUE (0x0002) /* VSY polarity */
476 #define BMC0_HSYTRUE (0x0001) /* HSY polarity */
477
478
479 /*
480 * FMODE -- Fetch Mode Control Register (AGA)
481 */
482
483 #define FMODE_SSCAN2 (0x8000) /* Sprite scan-doubling */
484 #define FMODE_BSCAN2 (0x4000) /* Use PF2 modulus every other line */
485 #define FMODE_SPAGEM (0x0008) /* Sprite page mode */
486 #define FMODE_SPR32 (0x0004) /* Sprite 32 bit fetch */
487 #define FMODE_BPAGEM (0x0002) /* Bitplane page mode */
488 #define FMODE_BPL32 (0x0001) /* Bitplane 32 bit fetch */
489
490 /*
491 * Tags used to indicate a specific Pixel Clock
492 *
493 * clk_shift is the shift value to get the timings in 35 ns units
494 */
495
496 enum { TAG_SHRES, TAG_HIRES, TAG_LORES };
497
498 /*
499 * Tags used to indicate the specific chipset
500 */
501
502 enum { TAG_OCS, TAG_ECS, TAG_AGA };
503
504 /*
505 * Tags used to indicate the memory bandwidth
506 */
507
508 enum { TAG_FMODE_1, TAG_FMODE_2, TAG_FMODE_4 };
509
510
511 /*
512 * Clock Definitions, Maximum Display Depth
513 *
514 * These depend on the E-Clock or the Chipset, so they are filled in
515 * dynamically
516 */
517
518 static u_long pixclock[3]; /* SHRES/HIRES/LORES: index = clk_shift */
519 static u_short maxdepth[3]; /* SHRES/HIRES/LORES: index = clk_shift */
520 static u_short maxfmode, chipset;
521
522
523 /*
524 * Broadcast Video Timings
525 *
526 * Horizontal values are in 35 ns (SHRES) units
527 * Vertical values are in interlaced scanlines
528 */
529
530 #define PAL_DIWSTRT_H (360) /* PAL Window Limits */
531 #define PAL_DIWSTRT_V (48)
532 #define PAL_HTOTAL (1816)
533 #define PAL_VTOTAL (625)
534
535 #define NTSC_DIWSTRT_H (360) /* NTSC Window Limits */
536 #define NTSC_DIWSTRT_V (40)
537 #define NTSC_HTOTAL (1816)
538 #define NTSC_VTOTAL (525)
539
540
541 /*
542 * Various macros
543 */
544
545 #define up2(v) (((v)+1) & -2)
546 #define down2(v) ((v) & -2)
547 #define div2(v) ((v)>>1)
548 #define mod2(v) ((v) & 1)
549
550 #define up4(v) (((v)+3) & -4)
551 #define down4(v) ((v) & -4)
552 #define mul4(v) ((v)<<2)
553 #define div4(v) ((v)>>2)
554 #define mod4(v) ((v) & 3)
555
556 #define up8(v) (((v)+7) & -8)
557 #define down8(v) ((v) & -8)
558 #define div8(v) ((v)>>3)
559 #define mod8(v) ((v) & 7)
560
561 #define up16(v) (((v)+15) & -16)
562 #define down16(v) ((v) & -16)
563 #define div16(v) ((v)>>4)
564 #define mod16(v) ((v) & 15)
565
566 #define up32(v) (((v)+31) & -32)
567 #define down32(v) ((v) & -32)
568 #define div32(v) ((v)>>5)
569 #define mod32(v) ((v) & 31)
570
571 #define up64(v) (((v)+63) & -64)
572 #define down64(v) ((v) & -64)
573 #define div64(v) ((v)>>6)
574 #define mod64(v) ((v) & 63)
575
576 #define upx(x,v) (((v)+(x)-1) & -(x))
577 #define downx(x,v) ((v) & -(x))
578 #define modx(x,v) ((v) & ((x)-1))
579
580 /* if x1 is not a constant, this macro won't make real sense :-) */
581 #ifdef __mc68000__
582 #define DIVUL(x1, x2) ({int res; asm("divul %1,%2,%3": "=d" (res): \
583 "d" (x2), "d" ((long)((x1)/0x100000000ULL)), "0" ((long)(x1))); res;})
584 #else
585 /* We know a bit about the numbers, so we can do it this way */
586 #define DIVUL(x1, x2) ((((long)((unsigned long long)x1 >> 8) / x2) << 8) + \
587 ((((long)((unsigned long long)x1 >> 8) % x2) << 8) / x2))
588 #endif
589
590 #define highw(x) ((u_long)(x)>>16 & 0xffff)
591 #define loww(x) ((u_long)(x) & 0xffff)
592
593 #define VBlankOn() custom.intena = IF_SETCLR|IF_COPER
594 #define VBlankOff() custom.intena = IF_COPER
595
596
597 /*
598 * Chip RAM we reserve for the Frame Buffer
599 *
600 * This defines the Maximum Virtual Screen Size
601 * (Setable per kernel options?)
602 */
603
604 #define VIDEOMEMSIZE_AGA_2M (1310720) /* AGA (2MB) : max 1280*1024*256 */
605 #define VIDEOMEMSIZE_AGA_1M (786432) /* AGA (1MB) : max 1024*768*256 */
606 #define VIDEOMEMSIZE_ECS_2M (655360) /* ECS (2MB) : max 1280*1024*16 */
607 #define VIDEOMEMSIZE_ECS_1M (393216) /* ECS (1MB) : max 1024*768*16 */
608 #define VIDEOMEMSIZE_OCS (262144) /* OCS : max ca. 800*600*16 */
609
610 #define SPRITEMEMSIZE (64*64/4) /* max 64*64*4 */
611 #define DUMMYSPRITEMEMSIZE (8)
612 static u_long spritememory;
613
614 #define CHIPRAM_SAFETY_LIMIT (16384)
615
616 static u_long videomemory;
617
618 /*
619 * This is the earliest allowed start of fetching display data.
620 * Only if you really want no hardware cursor and audio,
621 * set this to 128, but let it better at 192
622 */
623
624 static u_long min_fstrt = 192;
625
626 #define assignchunk(name, type, ptr, size) \
627 { \
628 (name) = (type)(ptr); \
629 ptr += size; \
630 }
631
632
633 /*
634 * Copper Instructions
635 */
636
637 #define CMOVE(val, reg) (CUSTOM_OFS(reg)<<16 | (val))
638 #define CMOVE2(val, reg) ((CUSTOM_OFS(reg)+2)<<16 | (val))
639 #define CWAIT(x, y) (((y) & 0x1fe)<<23 | ((x) & 0x7f0)<<13 | 0x0001fffe)
640 #define CEND (0xfffffffe)
641
642
643 typedef union {
644 u_long l;
645 u_short w[2];
646 } copins;
647
648 static struct copdisplay {
649 copins *init;
650 copins *wait;
651 copins *list[2][2];
652 copins *rebuild[2];
653 } copdisplay;
654
655 static u_short currentcop = 0;
656
657 /*
658 * Hardware Cursor API Definitions
659 * These used to be in linux/fb.h, but were preliminary and used by
660 * amifb only anyway
661 */
662
663 #define FBIOGET_FCURSORINFO 0x4607
664 #define FBIOGET_VCURSORINFO 0x4608
665 #define FBIOPUT_VCURSORINFO 0x4609
666 #define FBIOGET_CURSORSTATE 0x460A
667 #define FBIOPUT_CURSORSTATE 0x460B
668
669
670 struct fb_fix_cursorinfo {
671 __u16 crsr_width; /* width and height of the cursor in */
672 __u16 crsr_height; /* pixels (zero if no cursor) */
673 __u16 crsr_xsize; /* cursor size in display pixels */
674 __u16 crsr_ysize;
675 __u16 crsr_color1; /* colormap entry for cursor color1 */
676 __u16 crsr_color2; /* colormap entry for cursor color2 */
677 };
678
679 struct fb_var_cursorinfo {
680 __u16 width;
681 __u16 height;
682 __u16 xspot;
683 __u16 yspot;
684 __u8 data[1]; /* field with [height][width] */
685 };
686
687 struct fb_cursorstate {
688 __s16 xoffset;
689 __s16 yoffset;
690 __u16 mode;
691 };
692
693 #define FB_CURSOR_OFF 0
694 #define FB_CURSOR_ON 1
695 #define FB_CURSOR_FLASH 2
696
697
698 /*
699 * Hardware Cursor
700 */
701
702 static int cursorrate = 20; /* Number of frames/flash toggle */
703 static u_short cursorstate = -1;
704 static u_short cursormode = FB_CURSOR_OFF;
705
706 static u_short *lofsprite, *shfsprite, *dummysprite;
707
708 /*
709 * Current Video Mode
710 */
711
712 static struct amifb_par {
713
714 /* General Values */
715
716 int xres; /* vmode */
717 int yres; /* vmode */
718 int vxres; /* vmode */
719 int vyres; /* vmode */
720 int xoffset; /* vmode */
721 int yoffset; /* vmode */
722 u_short bpp; /* vmode */
723 u_short clk_shift; /* vmode */
724 u_short line_shift; /* vmode */
725 int vmode; /* vmode */
726 u_short diwstrt_h; /* vmode */
727 u_short diwstop_h; /* vmode */
728 u_short diwstrt_v; /* vmode */
729 u_short diwstop_v; /* vmode */
730 u_long next_line; /* modulo for next line */
731 u_long next_plane; /* modulo for next plane */
732
733 /* Cursor Values */
734
735 struct {
736 short crsr_x; /* movecursor */
737 short crsr_y; /* movecursor */
738 short spot_x;
739 short spot_y;
740 u_short height;
741 u_short width;
742 u_short fmode;
743 } crsr;
744
745 /* OCS Hardware Registers */
746
747 u_long bplpt0; /* vmode, pan (Note: physical address) */
748 u_long bplpt0wrap; /* vmode, pan (Note: physical address) */
749 u_short ddfstrt;
750 u_short ddfstop;
751 u_short bpl1mod;
752 u_short bpl2mod;
753 u_short bplcon0; /* vmode */
754 u_short bplcon1; /* vmode */
755 u_short htotal; /* vmode */
756 u_short vtotal; /* vmode */
757
758 /* Additional ECS Hardware Registers */
759
760 u_short bplcon3; /* vmode */
761 u_short beamcon0; /* vmode */
762 u_short hsstrt; /* vmode */
763 u_short hsstop; /* vmode */
764 u_short hbstrt; /* vmode */
765 u_short hbstop; /* vmode */
766 u_short vsstrt; /* vmode */
767 u_short vsstop; /* vmode */
768 u_short vbstrt; /* vmode */
769 u_short vbstop; /* vmode */
770 u_short hcenter; /* vmode */
771
772 /* Additional AGA Hardware Registers */
773
774 u_short fmode; /* vmode */
775 } currentpar;
776
777
778 static struct fb_info fb_info = {
779 .fix = {
780 .id = "Amiga ",
781 .visual = FB_VISUAL_PSEUDOCOLOR,
782 .accel = FB_ACCEL_AMIGABLITT
783 }
784 };
785
786
787 /*
788 * Saved color entry 0 so we can restore it when unblanking
789 */
790
791 static u_char red0, green0, blue0;
792
793
794 #if defined(CONFIG_FB_AMIGA_ECS)
795 static u_short ecs_palette[32];
796 #endif
797
798
799 /*
800 * Latches for Display Changes during VBlank
801 */
802
803 static u_short do_vmode_full = 0; /* Change the Video Mode */
804 static u_short do_vmode_pan = 0; /* Update the Video Mode */
805 static short do_blank = 0; /* (Un)Blank the Screen (±1) */
806 static u_short do_cursor = 0; /* Move the Cursor */
807
808
809 /*
810 * Various Flags
811 */
812
813 static u_short is_blanked = 0; /* Screen is Blanked */
814 static u_short is_lace = 0; /* Screen is laced */
815
816 /*
817 * Predefined Video Modes
818 *
819 */
820
821 static struct fb_videomode ami_modedb[] __initdata = {
822
823 /*
824 * AmigaOS Video Modes
825 *
826 * If you change these, make sure to update DEFMODE_* as well!
827 */
828
829 {
830 /* 640x200, 15 kHz, 60 Hz (NTSC) */
831 "ntsc", 60, 640, 200, TAG_HIRES, 106, 86, 44, 16, 76, 2,
832 FB_SYNC_BROADCAST, FB_VMODE_NONINTERLACED | FB_VMODE_YWRAP
833 }, {
834 /* 640x400, 15 kHz, 60 Hz interlaced (NTSC) */
835 "ntsc-lace", 60, 640, 400, TAG_HIRES, 106, 86, 88, 33, 76, 4,
836 FB_SYNC_BROADCAST, FB_VMODE_INTERLACED | FB_VMODE_YWRAP
837 }, {
838 /* 640x256, 15 kHz, 50 Hz (PAL) */
839 "pal", 50, 640, 256, TAG_HIRES, 106, 86, 40, 14, 76, 2,
840 FB_SYNC_BROADCAST, FB_VMODE_NONINTERLACED | FB_VMODE_YWRAP
841 }, {
842 /* 640x512, 15 kHz, 50 Hz interlaced (PAL) */
843 "pal-lace", 50, 640, 512, TAG_HIRES, 106, 86, 80, 29, 76, 4,
844 FB_SYNC_BROADCAST, FB_VMODE_INTERLACED | FB_VMODE_YWRAP
845 }, {
846 /* 640x480, 29 kHz, 57 Hz */
847 "multiscan", 57, 640, 480, TAG_SHRES, 96, 112, 29, 8, 72, 8,
848 0, FB_VMODE_NONINTERLACED | FB_VMODE_YWRAP
849 }, {
850 /* 640x960, 29 kHz, 57 Hz interlaced */
851 "multiscan-lace", 57, 640, 960, TAG_SHRES, 96, 112, 58, 16, 72, 16,
852 0, FB_VMODE_INTERLACED | FB_VMODE_YWRAP
853 }, {
854 /* 640x200, 15 kHz, 72 Hz */
855 "euro36", 72, 640, 200, TAG_HIRES, 92, 124, 6, 6, 52, 5,
856 0, FB_VMODE_NONINTERLACED | FB_VMODE_YWRAP
857 }, {
858 /* 640x400, 15 kHz, 72 Hz interlaced */
859 "euro36-lace", 72, 640, 400, TAG_HIRES, 92, 124, 12, 12, 52, 10,
860 0, FB_VMODE_INTERLACED | FB_VMODE_YWRAP
861 }, {
862 /* 640x400, 29 kHz, 68 Hz */
863 "euro72", 68, 640, 400, TAG_SHRES, 164, 92, 9, 9, 80, 8,
864 0, FB_VMODE_NONINTERLACED | FB_VMODE_YWRAP
865 }, {
866 /* 640x800, 29 kHz, 68 Hz interlaced */
867 "euro72-lace", 68, 640, 800, TAG_SHRES, 164, 92, 18, 18, 80, 16,
868 0, FB_VMODE_INTERLACED | FB_VMODE_YWRAP
869 }, {
870 /* 800x300, 23 kHz, 70 Hz */
871 "super72", 70, 800, 300, TAG_SHRES, 212, 140, 10, 11, 80, 7,
872 0, FB_VMODE_NONINTERLACED | FB_VMODE_YWRAP
873 }, {
874 /* 800x600, 23 kHz, 70 Hz interlaced */
875 "super72-lace", 70, 800, 600, TAG_SHRES, 212, 140, 20, 22, 80, 14,
876 0, FB_VMODE_INTERLACED | FB_VMODE_YWRAP
877 }, {
878 /* 640x200, 27 kHz, 57 Hz doublescan */
879 "dblntsc", 57, 640, 200, TAG_SHRES, 196, 124, 18, 17, 80, 4,
880 0, FB_VMODE_DOUBLE | FB_VMODE_YWRAP
881 }, {
882 /* 640x400, 27 kHz, 57 Hz */
883 "dblntsc-ff", 57, 640, 400, TAG_SHRES, 196, 124, 36, 35, 80, 7,
884 0, FB_VMODE_NONINTERLACED | FB_VMODE_YWRAP
885 }, {
886 /* 640x800, 27 kHz, 57 Hz interlaced */
887 "dblntsc-lace", 57, 640, 800, TAG_SHRES, 196, 124, 72, 70, 80, 14,
888 0, FB_VMODE_INTERLACED | FB_VMODE_YWRAP
889 }, {
890 /* 640x256, 27 kHz, 47 Hz doublescan */
891 "dblpal", 47, 640, 256, TAG_SHRES, 196, 124, 14, 13, 80, 4,
892 0, FB_VMODE_DOUBLE | FB_VMODE_YWRAP
893 }, {
894 /* 640x512, 27 kHz, 47 Hz */
895 "dblpal-ff", 47, 640, 512, TAG_SHRES, 196, 124, 28, 27, 80, 7,
896 0, FB_VMODE_NONINTERLACED | FB_VMODE_YWRAP
897 }, {
898 /* 640x1024, 27 kHz, 47 Hz interlaced */
899 "dblpal-lace", 47, 640, 1024, TAG_SHRES, 196, 124, 56, 54, 80, 14,
900 0, FB_VMODE_INTERLACED | FB_VMODE_YWRAP
901 },
902
903 /*
904 * VGA Video Modes
905 */
906
907 {
908 /* 640x480, 31 kHz, 60 Hz (VGA) */
909 "vga", 60, 640, 480, TAG_SHRES, 64, 96, 30, 9, 112, 2,
910 0, FB_VMODE_NONINTERLACED | FB_VMODE_YWRAP
911 }, {
912 /* 640x400, 31 kHz, 70 Hz (VGA) */
913 "vga70", 70, 640, 400, TAG_SHRES, 64, 96, 35, 12, 112, 2,
914 FB_SYNC_VERT_HIGH_ACT | FB_SYNC_COMP_HIGH_ACT, FB_VMODE_NONINTERLACED | FB_VMODE_YWRAP
915 },
916
917 #if 0
918
919 /*
920 * A2024 video modes
921 * These modes don't work yet because there's no A2024 driver.
922 */
923
924 {
925 /* 1024x800, 10 Hz */
926 "a2024-10", 10, 1024, 800, TAG_HIRES, 0, 0, 0, 0, 0, 0,
927 0, FB_VMODE_NONINTERLACED | FB_VMODE_YWRAP
928 }, {
929 /* 1024x800, 15 Hz */
930 "a2024-15", 15, 1024, 800, TAG_HIRES, 0, 0, 0, 0, 0, 0,
931 0, FB_VMODE_NONINTERLACED | FB_VMODE_YWRAP
932 }
933 #endif
934 };
935
936 #define NUM_TOTAL_MODES ARRAY_SIZE(ami_modedb)
937
938 static char *mode_option __initdata = NULL;
939 static int round_down_bpp = 1; /* for mode probing */
940
941 /*
942 * Some default modes
943 */
944
945
946 #define DEFMODE_PAL 2 /* "pal" for PAL OCS/ECS */
947 #define DEFMODE_NTSC 0 /* "ntsc" for NTSC OCS/ECS */
948 #define DEFMODE_AMBER_PAL 3 /* "pal-lace" for flicker fixed PAL (A3000) */
949 #define DEFMODE_AMBER_NTSC 1 /* "ntsc-lace" for flicker fixed NTSC (A3000) */
950 #define DEFMODE_AGA 19 /* "vga70" for AGA */
951
952
953 static int amifb_ilbm = 0; /* interleaved or normal bitplanes */
954 static int amifb_inverse = 0;
955
956
957 /*
958 * Macros for the conversion from real world values to hardware register
959 * values
960 *
961 * This helps us to keep our attention on the real stuff...
962 *
963 * Hardware limits for AGA:
964 *
965 * parameter min max step
966 * --------- --- ---- ----
967 * diwstrt_h 0 2047 1
968 * diwstrt_v 0 2047 1
969 * diwstop_h 0 4095 1
970 * diwstop_v 0 4095 1
971 *
972 * ddfstrt 0 2032 16
973 * ddfstop 0 2032 16
974 *
975 * htotal 8 2048 8
976 * hsstrt 0 2040 8
977 * hsstop 0 2040 8
978 * vtotal 1 4096 1
979 * vsstrt 0 4095 1
980 * vsstop 0 4095 1
981 * hcenter 0 2040 8
982 *
983 * hbstrt 0 2047 1
984 * hbstop 0 2047 1
985 * vbstrt 0 4095 1
986 * vbstop 0 4095 1
987 *
988 * Horizontal values are in 35 ns (SHRES) pixels
989 * Vertical values are in half scanlines
990 */
991
992 /* bplcon1 (smooth scrolling) */
993
994 #define hscroll2hw(hscroll) \
995 (((hscroll)<<12 & 0x3000) | ((hscroll)<<8 & 0xc300) | \
996 ((hscroll)<<4 & 0x0c00) | ((hscroll)<<2 & 0x00f0) | ((hscroll)>>2 & 0x000f))
997
998 /* diwstrt/diwstop/diwhigh (visible display window) */
999
1000 #define diwstrt2hw(diwstrt_h, diwstrt_v) \
1001 (((diwstrt_v)<<7 & 0xff00) | ((diwstrt_h)>>2 & 0x00ff))
1002 #define diwstop2hw(diwstop_h, diwstop_v) \
1003 (((diwstop_v)<<7 & 0xff00) | ((diwstop_h)>>2 & 0x00ff))
1004 #define diwhigh2hw(diwstrt_h, diwstrt_v, diwstop_h, diwstop_v) \
1005 (((diwstop_h)<<3 & 0x2000) | ((diwstop_h)<<11 & 0x1800) | \
1006 ((diwstop_v)>>1 & 0x0700) | ((diwstrt_h)>>5 & 0x0020) | \
1007 ((diwstrt_h)<<3 & 0x0018) | ((diwstrt_v)>>9 & 0x0007))
1008
1009 /* ddfstrt/ddfstop (display DMA) */
1010
1011 #define ddfstrt2hw(ddfstrt) div8(ddfstrt)
1012 #define ddfstop2hw(ddfstop) div8(ddfstop)
1013
1014 /* hsstrt/hsstop/htotal/vsstrt/vsstop/vtotal/hcenter (sync timings) */
1015
1016 #define hsstrt2hw(hsstrt) (div8(hsstrt))
1017 #define hsstop2hw(hsstop) (div8(hsstop))
1018 #define htotal2hw(htotal) (div8(htotal)-1)
1019 #define vsstrt2hw(vsstrt) (div2(vsstrt))
1020 #define vsstop2hw(vsstop) (div2(vsstop))
1021 #define vtotal2hw(vtotal) (div2(vtotal)-1)
1022 #define hcenter2hw(htotal) (div8(htotal))
1023
1024 /* hbstrt/hbstop/vbstrt/vbstop (blanking timings) */
1025
1026 #define hbstrt2hw(hbstrt) (((hbstrt)<<8 & 0x0700) | ((hbstrt)>>3 & 0x00ff))
1027 #define hbstop2hw(hbstop) (((hbstop)<<8 & 0x0700) | ((hbstop)>>3 & 0x00ff))
1028 #define vbstrt2hw(vbstrt) (div2(vbstrt))
1029 #define vbstop2hw(vbstop) (div2(vbstop))
1030
1031 /* colour */
1032
1033 #define rgb2hw8_high(red, green, blue) \
1034 (((red & 0xf0)<<4) | (green & 0xf0) | ((blue & 0xf0)>>4))
1035 #define rgb2hw8_low(red, green, blue) \
1036 (((red & 0x0f)<<8) | ((green & 0x0f)<<4) | (blue & 0x0f))
1037 #define rgb2hw4(red, green, blue) \
1038 (((red & 0xf0)<<4) | (green & 0xf0) | ((blue & 0xf0)>>4))
1039 #define rgb2hw2(red, green, blue) \
1040 (((red & 0xc0)<<4) | (green & 0xc0) | ((blue & 0xc0)>>4))
1041
1042 /* sprpos/sprctl (sprite positioning) */
1043
1044 #define spr2hw_pos(start_v, start_h) \
1045 (((start_v)<<7&0xff00) | ((start_h)>>3&0x00ff))
1046 #define spr2hw_ctl(start_v, start_h, stop_v) \
1047 (((stop_v)<<7&0xff00) | ((start_v)>>4&0x0040) | ((stop_v)>>5&0x0020) | \
1048 ((start_h)<<3&0x0018) | ((start_v)>>7&0x0004) | ((stop_v)>>8&0x0002) | \
1049 ((start_h)>>2&0x0001))
1050
1051 /* get current vertical position of beam */
1052 #define get_vbpos() ((u_short)((*(u_long volatile *)&custom.vposr >> 7) & 0xffe))
1053
1054 /*
1055 * Copper Initialisation List
1056 */
1057
1058 #define COPINITSIZE (sizeof(copins)*40)
1059
1060 enum {
1061 cip_bplcon0
1062 };
1063
1064 /*
1065 * Long Frame/Short Frame Copper List
1066 * Don't change the order, build_copper()/rebuild_copper() rely on this
1067 */
1068
1069 #define COPLISTSIZE (sizeof(copins)*64)
1070
1071 enum {
1072 cop_wait, cop_bplcon0,
1073 cop_spr0ptrh, cop_spr0ptrl,
1074 cop_diwstrt, cop_diwstop,
1075 cop_diwhigh,
1076 };
1077
1078 /*
1079 * Pixel modes for Bitplanes and Sprites
1080 */
1081
1082 static u_short bplpixmode[3] = {
1083 BPC0_SHRES, /* 35 ns */
1084 BPC0_HIRES, /* 70 ns */
1085 0 /* 140 ns */
1086 };
1087
1088 static u_short sprpixmode[3] = {
1089 BPC3_SPRES1 | BPC3_SPRES0, /* 35 ns */
1090 BPC3_SPRES1, /* 70 ns */
1091 BPC3_SPRES0 /* 140 ns */
1092 };
1093
1094 /*
1095 * Fetch modes for Bitplanes and Sprites
1096 */
1097
1098 static u_short bplfetchmode[3] = {
1099 0, /* 1x */
1100 FMODE_BPL32, /* 2x */
1101 FMODE_BPAGEM | FMODE_BPL32 /* 4x */
1102 };
1103
1104 static u_short sprfetchmode[3] = {
1105 0, /* 1x */
1106 FMODE_SPR32, /* 2x */
1107 FMODE_SPAGEM | FMODE_SPR32 /* 4x */
1108 };
1109
1110
1111 /*
1112 * Interface used by the world
1113 */
1114
1115 int amifb_setup(char*);
1116
1117 static int amifb_check_var(struct fb_var_screeninfo *var,
1118 struct fb_info *info);
1119 static int amifb_set_par(struct fb_info *info);
1120 static int amifb_setcolreg(unsigned regno, unsigned red, unsigned green,
1121 unsigned blue, unsigned transp,
1122 struct fb_info *info);
1123 static int amifb_blank(int blank, struct fb_info *info);
1124 static int amifb_pan_display(struct fb_var_screeninfo *var,
1125 struct fb_info *info);
1126 static void amifb_fillrect(struct fb_info *info,
1127 const struct fb_fillrect *rect);
1128 static void amifb_copyarea(struct fb_info *info,
1129 const struct fb_copyarea *region);
1130 static void amifb_imageblit(struct fb_info *info,
1131 const struct fb_image *image);
1132 static int amifb_ioctl(struct inode *inode, struct file *file,
1133 unsigned int cmd, unsigned long arg,
1134 struct fb_info *info);
1135
1136
1137 /*
1138 * Interface to the low level console driver
1139 */
1140
1141 int amifb_init(void);
1142 static void amifb_deinit(void);
1143
1144 /*
1145 * Internal routines
1146 */
1147
1148 static int flash_cursor(void);
1149 static irqreturn_t amifb_interrupt(int irq, void *dev_id, struct pt_regs *fp);
1150 static u_long chipalloc(u_long size);
1151 static void chipfree(void);
1152
1153 /*
1154 * Hardware routines
1155 */
1156
1157 static int ami_decode_var(struct fb_var_screeninfo *var,
1158 struct amifb_par *par);
1159 static int ami_encode_var(struct fb_var_screeninfo *var,
1160 struct amifb_par *par);
1161 static void ami_pan_var(struct fb_var_screeninfo *var);
1162 static int ami_update_par(void);
1163 static void ami_update_display(void);
1164 static void ami_init_display(void);
1165 static void ami_do_blank(void);
1166 static int ami_get_fix_cursorinfo(struct fb_fix_cursorinfo *fix);
1167 static int ami_get_var_cursorinfo(struct fb_var_cursorinfo *var, u_char *data);
1168 static int ami_set_var_cursorinfo(struct fb_var_cursorinfo *var, u_char *data);
1169 static int ami_get_cursorstate(struct fb_cursorstate *state);
1170 static int ami_set_cursorstate(struct fb_cursorstate *state);
1171 static void ami_set_sprite(void);
1172 static void ami_init_copper(void);
1173 static void ami_reinit_copper(void);
1174 static void ami_build_copper(void);
1175 static void ami_rebuild_copper(void);
1176
1177
1178 static struct fb_ops amifb_ops = {
1179 .owner = THIS_MODULE,
1180 .fb_check_var = amifb_check_var,
1181 .fb_set_par = amifb_set_par,
1182 .fb_setcolreg = amifb_setcolreg,
1183 .fb_blank = amifb_blank,
1184 .fb_pan_display = amifb_pan_display,
1185 .fb_fillrect = amifb_fillrect,
1186 .fb_copyarea = amifb_copyarea,
1187 .fb_imageblit = amifb_imageblit,
1188 .fb_cursor = soft_cursor,
1189 .fb_ioctl = amifb_ioctl,
1190 };
1191
1192 static void __init amifb_setup_mcap(char *spec)
1193 {
1194 char *p;
1195 int vmin, vmax, hmin, hmax;
1196
1197 /* Format for monitor capabilities is: <Vmin>;<Vmax>;<Hmin>;<Hmax>
1198 * <V*> vertical freq. in Hz
1199 * <H*> horizontal freq. in kHz
1200 */
1201
1202 if (!(p = strsep(&spec, ";")) || !*p)
1203 return;
1204 vmin = simple_strtoul(p, NULL, 10);
1205 if (vmin <= 0)
1206 return;
1207 if (!(p = strsep(&spec, ";")) || !*p)
1208 return;
1209 vmax = simple_strtoul(p, NULL, 10);
1210 if (vmax <= 0 || vmax <= vmin)
1211 return;
1212 if (!(p = strsep(&spec, ";")) || !*p)
1213 return;
1214 hmin = 1000 * simple_strtoul(p, NULL, 10);
1215 if (hmin <= 0)
1216 return;
1217 if (!(p = strsep(&spec, "")) || !*p)
1218 return;
1219 hmax = 1000 * simple_strtoul(p, NULL, 10);
1220 if (hmax <= 0 || hmax <= hmin)
1221 return;
1222
1223 fb_info.monspecs.vfmin = vmin;
1224 fb_info.monspecs.vfmax = vmax;
1225 fb_info.monspecs.hfmin = hmin;
1226 fb_info.monspecs.hfmax = hmax;
1227 }
1228
1229 int __init amifb_setup(char *options)
1230 {
1231 char *this_opt;
1232
1233 if (!options || !*options)
1234 return 0;
1235
1236 while ((this_opt = strsep(&options, ",")) != NULL) {
1237 if (!*this_opt)
1238 continue;
1239 if (!strcmp(this_opt, "inverse")) {
1240 amifb_inverse = 1;
1241 fb_invert_cmaps();
1242 } else if (!strcmp(this_opt, "ilbm"))
1243 amifb_ilbm = 1;
1244 else if (!strncmp(this_opt, "monitorcap:", 11))
1245 amifb_setup_mcap(this_opt+11);
1246 else if (!strncmp(this_opt, "fstart:", 7))
1247 min_fstrt = simple_strtoul(this_opt+7, NULL, 0);
1248 else
1249 mode_option = this_opt;
1250 }
1251
1252 if (min_fstrt < 48)
1253 min_fstrt = 48;
1254
1255 return 0;
1256 }
1257
1258
1259 static int amifb_check_var(struct fb_var_screeninfo *var,
1260 struct fb_info *info)
1261 {
1262 int err;
1263 struct amifb_par par;
1264
1265 /* Validate wanted screen parameters */
1266 if ((err = ami_decode_var(var, &par)))
1267 return err;
1268
1269 /* Encode (possibly rounded) screen parameters */
1270 ami_encode_var(var, &par);
1271 return 0;
1272 }
1273
1274
1275 static int amifb_set_par(struct fb_info *info)
1276 {
1277 struct amifb_par *par = (struct amifb_par *)info->par;
1278
1279 do_vmode_pan = 0;
1280 do_vmode_full = 0;
1281
1282 /* Decode wanted screen parameters */
1283 ami_decode_var(&info->var, par);
1284
1285 /* Set new videomode */
1286 ami_build_copper();
1287
1288 /* Set VBlank trigger */
1289 do_vmode_full = 1;
1290
1291 /* Update fix for new screen parameters */
1292 if (par->bpp == 1) {
1293 info->fix.type = FB_TYPE_PACKED_PIXELS;
1294 info->fix.type_aux = 0;
1295 } else if (amifb_ilbm) {
1296 info->fix.type = FB_TYPE_INTERLEAVED_PLANES;
1297 info->fix.type_aux = par->next_line;
1298 } else {
1299 info->fix.type = FB_TYPE_PLANES;
1300 info->fix.type_aux = 0;
1301 }
1302 info->fix.line_length = div8(upx(16<<maxfmode, par->vxres));
1303
1304 if (par->vmode & FB_VMODE_YWRAP) {
1305 info->fix.ywrapstep = 1;
1306 info->fix.xpanstep = 0;
1307 info->fix.ypanstep = 0;
1308 info->flags = FBINFO_DEFAULT | FBINFO_HWACCEL_YWRAP |
1309 FBINFO_READS_FAST; /* override SCROLL_REDRAW */
1310 } else {
1311 info->fix.ywrapstep = 0;
1312 if (par->vmode & FB_VMODE_SMOOTH_XPAN)
1313 info->fix.xpanstep = 1;
1314 else
1315 info->fix.xpanstep = 16<<maxfmode;
1316 info->fix.ypanstep = 1;
1317 info->flags = FBINFO_DEFAULT | FBINFO_HWACCEL_YPAN;
1318 }
1319 return 0;
1320 }
1321
1322
1323 /*
1324 * Pan or Wrap the Display
1325 *
1326 * This call looks only at xoffset, yoffset and the FB_VMODE_YWRAP flag
1327 */
1328
1329 static int amifb_pan_display(struct fb_var_screeninfo *var,
1330 struct fb_info *info)
1331 {
1332 if (var->vmode & FB_VMODE_YWRAP) {
1333 if (var->yoffset < 0 ||
1334 var->yoffset >= info->var.yres_virtual || var->xoffset)
1335 return -EINVAL;
1336 } else {
1337 /*
1338 * TODO: There will be problems when xpan!=1, so some columns
1339 * on the right side will never be seen
1340 */
1341 if (var->xoffset+info->var.xres > upx(16<<maxfmode, info->var.xres_virtual) ||
1342 var->yoffset+info->var.yres > info->var.yres_virtual)
1343 return -EINVAL;
1344 }
1345 ami_pan_var(var);
1346 info->var.xoffset = var->xoffset;
1347 info->var.yoffset = var->yoffset;
1348 if (var->vmode & FB_VMODE_YWRAP)
1349 info->var.vmode |= FB_VMODE_YWRAP;
1350 else
1351 info->var.vmode &= ~FB_VMODE_YWRAP;
1352 return 0;
1353 }
1354
1355
1356 #if BITS_PER_LONG == 32
1357 #define BYTES_PER_LONG 4
1358 #define SHIFT_PER_LONG 5
1359 #elif BITS_PER_LONG == 64
1360 #define BYTES_PER_LONG 8
1361 #define SHIFT_PER_LONG 6
1362 #else
1363 #define Please update me
1364 #endif
1365
1366
1367 /*
1368 * Compose two values, using a bitmask as decision value
1369 * This is equivalent to (a & mask) | (b & ~mask)
1370 */
1371
1372 static inline unsigned long comp(unsigned long a, unsigned long b,
1373 unsigned long mask)
1374 {
1375 return ((a ^ b) & mask) ^ b;
1376 }
1377
1378
1379 static inline unsigned long xor(unsigned long a, unsigned long b,
1380 unsigned long mask)
1381 {
1382 return (a & mask) ^ b;
1383 }
1384
1385
1386 /*
1387 * Unaligned forward bit copy using 32-bit or 64-bit memory accesses
1388 */
1389
1390 static void bitcpy(unsigned long *dst, int dst_idx, const unsigned long *src,
1391 int src_idx, u32 n)
1392 {
1393 unsigned long first, last;
1394 int shift = dst_idx-src_idx, left, right;
1395 unsigned long d0, d1;
1396 int m;
1397
1398 if (!n)
1399 return;
1400
1401 shift = dst_idx-src_idx;
1402 first = ~0UL >> dst_idx;
1403 last = ~(~0UL >> ((dst_idx+n) % BITS_PER_LONG));
1404
1405 if (!shift) {
1406 // Same alignment for source and dest
1407
1408 if (dst_idx+n <= BITS_PER_LONG) {
1409 // Single word
1410 if (last)
1411 first &= last;
1412 *dst = comp(*src, *dst, first);
1413 } else {
1414 // Multiple destination words
1415 // Leading bits
1416 if (first) {
1417 *dst = comp(*src, *dst, first);
1418 dst++;
1419 src++;
1420 n -= BITS_PER_LONG-dst_idx;
1421 }
1422
1423 // Main chunk
1424 n /= BITS_PER_LONG;
1425 while (n >= 8) {
1426 *dst++ = *src++;
1427 *dst++ = *src++;
1428 *dst++ = *src++;
1429 *dst++ = *src++;
1430 *dst++ = *src++;
1431 *dst++ = *src++;
1432 *dst++ = *src++;
1433 *dst++ = *src++;
1434 n -= 8;
1435 }
1436 while (n--)
1437 *dst++ = *src++;
1438
1439 // Trailing bits
1440 if (last)
1441 *dst = comp(*src, *dst, last);
1442 }
1443 } else {
1444 // Different alignment for source and dest
1445
1446 right = shift & (BITS_PER_LONG-1);
1447 left = -shift & (BITS_PER_LONG-1);
1448
1449 if (dst_idx+n <= BITS_PER_LONG) {
1450 // Single destination word
1451 if (last)
1452 first &= last;
1453 if (shift > 0) {
1454 // Single source word
1455 *dst = comp(*src >> right, *dst, first);
1456 } else if (src_idx+n <= BITS_PER_LONG) {
1457 // Single source word
1458 *dst = comp(*src << left, *dst, first);
1459 } else {
1460 // 2 source words
1461 d0 = *src++;
1462 d1 = *src;
1463 *dst = comp(d0 << left | d1 >> right, *dst,
1464 first);
1465 }
1466 } else {
1467 // Multiple destination words
1468 d0 = *src++;
1469 // Leading bits
1470 if (shift > 0) {
1471 // Single source word
1472 *dst = comp(d0 >> right, *dst, first);
1473 dst++;
1474 n -= BITS_PER_LONG-dst_idx;
1475 } else {
1476 // 2 source words
1477 d1 = *src++;
1478 *dst = comp(d0 << left | d1 >> right, *dst,
1479 first);
1480 d0 = d1;
1481 dst++;
1482 n -= BITS_PER_LONG-dst_idx;
1483 }
1484
1485 // Main chunk
1486 m = n % BITS_PER_LONG;
1487 n /= BITS_PER_LONG;
1488 while (n >= 4) {
1489 d1 = *src++;
1490 *dst++ = d0 << left | d1 >> right;
1491 d0 = d1;
1492 d1 = *src++;
1493 *dst++ = d0 << left | d1 >> right;
1494 d0 = d1;
1495 d1 = *src++;
1496 *dst++ = d0 << left | d1 >> right;
1497 d0 = d1;
1498 d1 = *src++;
1499 *dst++ = d0 << left | d1 >> right;
1500 d0 = d1;
1501 n -= 4;
1502 }
1503 while (n--) {
1504 d1 = *src++;
1505 *dst++ = d0 << left | d1 >> right;
1506 d0 = d1;
1507 }
1508
1509 // Trailing bits
1510 if (last) {
1511 if (m <= right) {
1512 // Single source word
1513 *dst = comp(d0 << left, *dst, last);
1514 } else {
1515 // 2 source words
1516 d1 = *src;
1517 *dst = comp(d0 << left | d1 >> right,
1518 *dst, last);
1519 }
1520 }
1521 }
1522 }
1523 }
1524
1525
1526 /*
1527 * Unaligned reverse bit copy using 32-bit or 64-bit memory accesses
1528 */
1529
1530 static void bitcpy_rev(unsigned long *dst, int dst_idx,
1531 const unsigned long *src, int src_idx, u32 n)
1532 {
1533 unsigned long first, last;
1534 int shift = dst_idx-src_idx, left, right;
1535 unsigned long d0, d1;
1536 int m;
1537
1538 if (!n)
1539 return;
1540
1541 dst += (n-1)/BITS_PER_LONG;
1542 src += (n-1)/BITS_PER_LONG;
1543 if ((n-1) % BITS_PER_LONG) {
1544 dst_idx += (n-1) % BITS_PER_LONG;
1545 dst += dst_idx >> SHIFT_PER_LONG;
1546 dst_idx &= BITS_PER_LONG-1;
1547 src_idx += (n-1) % BITS_PER_LONG;
1548 src += src_idx >> SHIFT_PER_LONG;
1549 src_idx &= BITS_PER_LONG-1;
1550 }
1551
1552 shift = dst_idx-src_idx;
1553 first = ~0UL << (BITS_PER_LONG-1-dst_idx);
1554 last = ~(~0UL << (BITS_PER_LONG-1-((dst_idx-n) % BITS_PER_LONG)));
1555
1556 if (!shift) {
1557 // Same alignment for source and dest
1558
1559 if ((unsigned long)dst_idx+1 >= n) {
1560 // Single word
1561 if (last)
1562 first &= last;
1563 *dst = comp(*src, *dst, first);
1564 } else {
1565 // Multiple destination words
1566 // Leading bits
1567 if (first) {
1568 *dst = comp(*src, *dst, first);
1569 dst--;
1570 src--;
1571 n -= dst_idx+1;
1572 }
1573
1574 // Main chunk
1575 n /= BITS_PER_LONG;
1576 while (n >= 8) {
1577 *dst-- = *src--;
1578 *dst-- = *src--;
1579 *dst-- = *src--;
1580 *dst-- = *src--;
1581 *dst-- = *src--;
1582 *dst-- = *src--;
1583 *dst-- = *src--;
1584 *dst-- = *src--;
1585 n -= 8;
1586 }
1587 while (n--)
1588 *dst-- = *src--;
1589
1590 // Trailing bits
1591 if (last)
1592 *dst = comp(*src, *dst, last);
1593 }
1594 } else {
1595 // Different alignment for source and dest
1596
1597 right = shift & (BITS_PER_LONG-1);
1598 left = -shift & (BITS_PER_LONG-1);
1599
1600 if ((unsigned long)dst_idx+1 >= n) {
1601 // Single destination word
1602 if (last)
1603 first &= last;
1604 if (shift < 0) {
1605 // Single source word
1606 *dst = comp(*src << left, *dst, first);
1607 } else if (1+(unsigned long)src_idx >= n) {
1608 // Single source word
1609 *dst = comp(*src >> right, *dst, first);
1610 } else {
1611 // 2 source words
1612 d0 = *src--;
1613 d1 = *src;
1614 *dst = comp(d0 >> right | d1 << left, *dst,
1615 first);
1616 }
1617 } else {
1618 // Multiple destination words
1619 d0 = *src--;
1620 // Leading bits
1621 if (shift < 0) {
1622 // Single source word
1623 *dst = comp(d0 << left, *dst, first);
1624 dst--;
1625 n -= dst_idx+1;
1626 } else {
1627 // 2 source words
1628 d1 = *src--;
1629 *dst = comp(d0 >> right | d1 << left, *dst,
1630 first);
1631 d0 = d1;
1632 dst--;
1633 n -= dst_idx+1;
1634 }
1635
1636 // Main chunk
1637 m = n % BITS_PER_LONG;
1638 n /= BITS_PER_LONG;
1639 while (n >= 4) {
1640 d1 = *src--;
1641 *dst-- = d0 >> right | d1 << left;
1642 d0 = d1;
1643 d1 = *src--;
1644 *dst-- = d0 >> right | d1 << left;
1645 d0 = d1;
1646 d1 = *src--;
1647 *dst-- = d0 >> right | d1 << left;
1648 d0 = d1;
1649 d1 = *src--;
1650 *dst-- = d0 >> right | d1 << left;
1651 d0 = d1;
1652 n -= 4;
1653 }
1654 while (n--) {
1655 d1 = *src--;
1656 *dst-- = d0 >> right | d1 << left;
1657 d0 = d1;
1658 }
1659
1660 // Trailing bits
1661 if (last) {
1662 if (m <= left) {
1663 // Single source word
1664 *dst = comp(d0 >> right, *dst, last);
1665 } else {
1666 // 2 source words
1667 d1 = *src;
1668 *dst = comp(d0 >> right | d1 << left,
1669 *dst, last);
1670 }
1671 }
1672 }
1673 }
1674 }
1675
1676
1677 /*
1678 * Unaligned forward inverting bit copy using 32-bit or 64-bit memory
1679 * accesses
1680 */
1681
1682 static void bitcpy_not(unsigned long *dst, int dst_idx,
1683 const unsigned long *src, int src_idx, u32 n)
1684 {
1685 unsigned long first, last;
1686 int shift = dst_idx-src_idx, left, right;
1687 unsigned long d0, d1;
1688 int m;
1689
1690 if (!n)
1691 return;
1692
1693 shift = dst_idx-src_idx;
1694 first = ~0UL >> dst_idx;
1695 last = ~(~0UL >> ((dst_idx+n) % BITS_PER_LONG));
1696
1697 if (!shift) {
1698 // Same alignment for source and dest
1699
1700 if (dst_idx+n <= BITS_PER_LONG) {
1701 // Single word
1702 if (last)
1703 first &= last;
1704 *dst = comp(~*src, *dst, first);
1705 } else {
1706 // Multiple destination words
1707 // Leading bits
1708 if (first) {
1709 *dst = comp(~*src, *dst, first);
1710 dst++;
1711 src++;
1712 n -= BITS_PER_LONG-dst_idx;
1713 }
1714
1715 // Main chunk
1716 n /= BITS_PER_LONG;
1717 while (n >= 8) {
1718 *dst++ = ~*src++;
1719 *dst++ = ~*src++;
1720 *dst++ = ~*src++;
1721 *dst++ = ~*src++;
1722 *dst++ = ~*src++;
1723 *dst++ = ~*src++;
1724 *dst++ = ~*src++;
1725 *dst++ = ~*src++;
1726 n -= 8;
1727 }
1728 while (n--)
1729 *dst++ = ~*src++;
1730
1731 // Trailing bits
1732 if (last)
1733 *dst = comp(~*src, *dst, last);
1734 }
1735 } else {
1736 // Different alignment for source and dest
1737
1738 right = shift & (BITS_PER_LONG-1);
1739 left = -shift & (BITS_PER_LONG-1);
1740
1741 if (dst_idx+n <= BITS_PER_LONG) {
1742 // Single destination word
1743 if (last)
1744 first &= last;
1745 if (shift > 0) {
1746 // Single source word
1747 *dst = comp(~*src >> right, *dst, first);
1748 } else if (src_idx+n <= BITS_PER_LONG) {
1749 // Single source word
1750 *dst = comp(~*src << left, *dst, first);
1751 } else {
1752 // 2 source words
1753 d0 = ~*src++;
1754 d1 = ~*src;
1755 *dst = comp(d0 << left | d1 >> right, *dst,
1756 first);
1757 }
1758 } else {
1759 // Multiple destination words
1760 d0 = ~*src++;
1761 // Leading bits
1762 if (shift > 0) {
1763 // Single source word
1764 *dst = comp(d0 >> right, *dst, first);
1765 dst++;
1766 n -= BITS_PER_LONG-dst_idx;
1767 } else {
1768 // 2 source words
1769 d1 = ~*src++;
1770 *dst = comp(d0 << left | d1 >> right, *dst,
1771 first);
1772 d0 = d1;
1773 dst++;
1774 n -= BITS_PER_LONG-dst_idx;
1775 }
1776
1777 // Main chunk
1778 m = n % BITS_PER_LONG;
1779 n /= BITS_PER_LONG;
1780 while (n >= 4) {
1781 d1 = ~*src++;
1782 *dst++ = d0 << left | d1 >> right;
1783 d0 = d1;
1784 d1 = ~*src++;
1785 *dst++ = d0 << left | d1 >> right;
1786 d0 = d1;
1787 d1 = ~*src++;
1788 *dst++ = d0 << left | d1 >> right;
1789 d0 = d1;
1790 d1 = ~*src++;
1791 *dst++ = d0 << left | d1 >> right;
1792 d0 = d1;
1793 n -= 4;
1794 }
1795 while (n--) {
1796 d1 = ~*src++;
1797 *dst++ = d0 << left | d1 >> right;
1798 d0 = d1;
1799 }
1800
1801 // Trailing bits
1802 if (last) {
1803 if (m <= right) {
1804 // Single source word
1805 *dst = comp(d0 << left, *dst, last);
1806 } else {
1807 // 2 source words
1808 d1 = ~*src;
1809 *dst = comp(d0 << left | d1 >> right,
1810 *dst, last);
1811 }
1812 }
1813 }
1814 }
1815 }
1816
1817
1818 /*
1819 * Unaligned 32-bit pattern fill using 32/64-bit memory accesses
1820 */
1821
1822 static void bitfill32(unsigned long *dst, int dst_idx, u32 pat, u32 n)
1823 {
1824 unsigned long val = pat;
1825 unsigned long first, last;
1826
1827 if (!n)
1828 return;
1829
1830 #if BITS_PER_LONG == 64
1831 val |= val << 32;
1832 #endif
1833
1834 first = ~0UL >> dst_idx;
1835 last = ~(~0UL >> ((dst_idx+n) % BITS_PER_LONG));
1836
1837 if (dst_idx+n <= BITS_PER_LONG) {
1838 // Single word
1839 if (last)
1840 first &= last;
1841 *dst = comp(val, *dst, first);
1842 } else {
1843 // Multiple destination words
1844 // Leading bits
1845 if (first) {
1846 *dst = comp(val, *dst, first);
1847 dst++;
1848 n -= BITS_PER_LONG-dst_idx;
1849 }
1850
1851 // Main chunk
1852 n /= BITS_PER_LONG;
1853 while (n >= 8) {
1854 *dst++ = val;
1855 *dst++ = val;
1856 *dst++ = val;
1857 *dst++ = val;
1858 *dst++ = val;
1859 *dst++ = val;
1860 *dst++ = val;
1861 *dst++ = val;
1862 n -= 8;
1863 }
1864 while (n--)
1865 *dst++ = val;
1866
1867 // Trailing bits
1868 if (last)
1869 *dst = comp(val, *dst, last);
1870 }
1871 }
1872
1873
1874 /*
1875 * Unaligned 32-bit pattern xor using 32/64-bit memory accesses
1876 */
1877
1878 static void bitxor32(unsigned long *dst, int dst_idx, u32 pat, u32 n)
1879 {
1880 unsigned long val = pat;
1881 unsigned long first, last;
1882
1883 if (!n)
1884 return;
1885
1886 #if BITS_PER_LONG == 64
1887 val |= val << 32;
1888 #endif
1889
1890 first = ~0UL >> dst_idx;
1891 last = ~(~0UL >> ((dst_idx+n) % BITS_PER_LONG));
1892
1893 if (dst_idx+n <= BITS_PER_LONG) {
1894 // Single word
1895 if (last)
1896 first &= last;
1897 *dst = xor(val, *dst, first);
1898 } else {
1899 // Multiple destination words
1900 // Leading bits
1901 if (first) {
1902 *dst = xor(val, *dst, first);
1903 dst++;
1904 n -= BITS_PER_LONG-dst_idx;
1905 }
1906
1907 // Main chunk
1908 n /= BITS_PER_LONG;
1909 while (n >= 4) {
1910 *dst++ ^= val;
1911 *dst++ ^= val;
1912 *dst++ ^= val;
1913 *dst++ ^= val;
1914 n -= 4;
1915 }
1916 while (n--)
1917 *dst++ ^= val;
1918
1919 // Trailing bits
1920 if (last)
1921 *dst = xor(val, *dst, last);
1922 }
1923 }
1924
1925 static inline void fill_one_line(int bpp, unsigned long next_plane,
1926 unsigned long *dst, int dst_idx, u32 n,
1927 u32 color)
1928 {
1929 while (1) {
1930 dst += dst_idx >> SHIFT_PER_LONG;
1931 dst_idx &= (BITS_PER_LONG-1);
1932 bitfill32(dst, dst_idx, color & 1 ? ~0 : 0, n);
1933 if (!--bpp)
1934 break;
1935 color >>= 1;
1936 dst_idx += next_plane*8;
1937 }
1938 }
1939
1940 static inline void xor_one_line(int bpp, unsigned long next_plane,
1941 unsigned long *dst, int dst_idx, u32 n,
1942 u32 color)
1943 {
1944 while (color) {
1945 dst += dst_idx >> SHIFT_PER_LONG;
1946 dst_idx &= (BITS_PER_LONG-1);
1947 bitxor32(dst, dst_idx, color & 1 ? ~0 : 0, n);
1948 if (!--bpp)
1949 break;
1950 color >>= 1;
1951 dst_idx += next_plane*8;
1952 }
1953 }
1954
1955
1956 static void amifb_fillrect(struct fb_info *info,
1957 const struct fb_fillrect *rect)
1958 {
1959 struct amifb_par *par = (struct amifb_par *)info->par;
1960 int dst_idx, x2, y2;
1961 unsigned long *dst;
1962 u32 width, height;
1963
1964 if (!rect->width || !rect->height)
1965 return;
1966
1967 /*
1968 * We could use hardware clipping but on many cards you get around
1969 * hardware clipping by writing to framebuffer directly.
1970 * */
1971 x2 = rect->dx + rect->width;
1972 y2 = rect->dy + rect->height;
1973 x2 = x2 < info->var.xres_virtual ? x2 : info->var.xres_virtual;
1974 y2 = y2 < info->var.yres_virtual ? y2 : info->var.yres_virtual;
1975 width = x2 - rect->dx;
1976 height = y2 - rect->dy;
1977
1978 dst = (unsigned long *)
1979 ((unsigned long)info->screen_base & ~(BYTES_PER_LONG-1));
1980 dst_idx = ((unsigned long)info->screen_base & (BYTES_PER_LONG-1))*8;
1981 dst_idx += rect->dy*par->next_line*8+rect->dx;
1982 while (height--) {
1983 switch (rect->rop) {
1984 case ROP_COPY:
1985 fill_one_line(info->var.bits_per_pixel,
1986 par->next_plane, dst, dst_idx, width,
1987 rect->color);
1988 break;
1989
1990 case ROP_XOR:
1991 xor_one_line(info->var.bits_per_pixel, par->next_plane,
1992 dst, dst_idx, width, rect->color);
1993 break;
1994 }
1995 dst_idx += par->next_line*8;
1996 }
1997 }
1998
1999 static inline void copy_one_line(int bpp, unsigned long next_plane,
2000 unsigned long *dst, int dst_idx,
2001 unsigned long *src, int src_idx, u32 n)
2002 {
2003 while (1) {
2004 dst += dst_idx >> SHIFT_PER_LONG;
2005 dst_idx &= (BITS_PER_LONG-1);
2006 src += src_idx >> SHIFT_PER_LONG;
2007 src_idx &= (BITS_PER_LONG-1);
2008 bitcpy(dst, dst_idx, src, src_idx, n);
2009 if (!--bpp)
2010 break;
2011 dst_idx += next_plane*8;
2012 src_idx += next_plane*8;
2013 }
2014 }
2015
2016 static inline void copy_one_line_rev(int bpp, unsigned long next_plane,
2017 unsigned long *dst, int dst_idx,
2018 unsigned long *src, int src_idx, u32 n)
2019 {
2020 while (1) {
2021 dst += dst_idx >> SHIFT_PER_LONG;
2022 dst_idx &= (BITS_PER_LONG-1);
2023 src += src_idx >> SHIFT_PER_LONG;
2024 src_idx &= (BITS_PER_LONG-1);
2025 bitcpy_rev(dst, dst_idx, src, src_idx, n);
2026 if (!--bpp)
2027 break;
2028 dst_idx += next_plane*8;
2029 src_idx += next_plane*8;
2030 }
2031 }
2032
2033
2034 static void amifb_copyarea(struct fb_info *info,
2035 const struct fb_copyarea *area)
2036 {
2037 struct amifb_par *par = (struct amifb_par *)info->par;
2038 int x2, y2;
2039 u32 dx, dy, sx, sy, width, height;
2040 unsigned long *dst, *src;
2041 int dst_idx, src_idx;
2042 int rev_copy = 0;
2043
2044 /* clip the destination */
2045 x2 = area->dx + area->width;
2046 y2 = area->dy + area->height;
2047 dx = area->dx > 0 ? area->dx : 0;
2048 dy = area->dy > 0 ? area->dy : 0;
2049 x2 = x2 < info->var.xres_virtual ? x2 : info->var.xres_virtual;
2050 y2 = y2 < info->var.yres_virtual ? y2 : info->var.yres_virtual;
2051 width = x2 - dx;
2052 height = y2 - dy;
2053
2054 /* update sx,sy */
2055 sx = area->sx + (dx - area->dx);
2056 sy = area->sy + (dy - area->dy);
2057
2058 /* the source must be completely inside the virtual screen */
2059 if (sx < 0 || sy < 0 || (sx + width) > info->var.xres_virtual ||
2060 (sy + height) > info->var.yres_virtual)
2061 return;
2062
2063 if (dy > sy || (dy == sy && dx > sx)) {
2064 dy += height;
2065 sy += height;
2066 rev_copy = 1;
2067 }
2068 dst = (unsigned long *)
2069 ((unsigned long)info->screen_base & ~(BYTES_PER_LONG-1));
2070 src = dst;
2071 dst_idx = ((unsigned long)info->screen_base & (BYTES_PER_LONG-1))*8;
2072 src_idx = dst_idx;
2073 dst_idx += dy*par->next_line*8+dx;
2074 src_idx += sy*par->next_line*8+sx;
2075 if (rev_copy) {
2076 while (height--) {
2077 dst_idx -= par->next_line*8;
2078 src_idx -= par->next_line*8;
2079 copy_one_line_rev(info->var.bits_per_pixel,
2080 par->next_plane, dst, dst_idx, src,
2081 src_idx, width);
2082 }
2083 } else {
2084 while (height--) {
2085 copy_one_line(info->var.bits_per_pixel,
2086 par->next_plane, dst, dst_idx, src,
2087 src_idx, width);
2088 dst_idx += par->next_line*8;
2089 src_idx += par->next_line*8;
2090 }
2091 }
2092 }
2093
2094
2095 static inline void expand_one_line(int bpp, unsigned long next_plane,
2096 unsigned long *dst, int dst_idx, u32 n,
2097 const u8 *data, u32 bgcolor, u32 fgcolor)
2098 {
2099 const unsigned long *src;
2100 int src_idx;
2101
2102 while (1) {
2103 dst += dst_idx >> SHIFT_PER_LONG;
2104 dst_idx &= (BITS_PER_LONG-1);
2105 if ((bgcolor ^ fgcolor) & 1) {
2106 src = (unsigned long *)((unsigned long)data & ~(BYTES_PER_LONG-1));
2107 src_idx = ((unsigned long)data & (BYTES_PER_LONG-1))*8;
2108 if (fgcolor & 1)
2109 bitcpy(dst, dst_idx, src, src_idx, n);
2110 else
2111 bitcpy_not(dst, dst_idx, src, src_idx, n);
2112 /* set or clear */
2113 } else
2114 bitfill32(dst, dst_idx, fgcolor & 1 ? ~0 : 0, n);
2115 if (!--bpp)
2116 break;
2117 bgcolor >>= 1;
2118 fgcolor >>= 1;
2119 dst_idx += next_plane*8;
2120 }
2121 }
2122
2123
2124 static void amifb_imageblit(struct fb_info *info, const struct fb_image *image)
2125 {
2126 struct amifb_par *par = (struct amifb_par *)info->par;
2127 int x2, y2;
2128 unsigned long *dst;
2129 int dst_idx;
2130 const char *src;
2131 u32 dx, dy, width, height, pitch;
2132
2133 /*
2134 * We could use hardware clipping but on many cards you get around
2135 * hardware clipping by writing to framebuffer directly like we are
2136 * doing here.
2137 */
2138 x2 = image->dx + image->width;
2139 y2 = image->dy + image->height;
2140 dx = image->dx;
2141 dy = image->dy;
2142 x2 = x2 < info->var.xres_virtual ? x2 : info->var.xres_virtual;
2143 y2 = y2 < info->var.yres_virtual ? y2 : info->var.yres_virtual;
2144 width = x2 - dx;
2145 height = y2 - dy;
2146
2147 if (image->depth == 1) {
2148 dst = (unsigned long *)
2149 ((unsigned long)info->screen_base & ~(BYTES_PER_LONG-1));
2150 dst_idx = ((unsigned long)info->screen_base & (BYTES_PER_LONG-1))*8;
2151 dst_idx += dy*par->next_line*8+dx;
2152 src = image->data;
2153 pitch = (image->width+7)/8;
2154 while (height--) {
2155 expand_one_line(info->var.bits_per_pixel,
2156 par->next_plane, dst, dst_idx, width,
2157 src, image->bg_color,
2158 image->fg_color);
2159 dst_idx += par->next_line*8;
2160 src += pitch;
2161 }
2162 } else {
2163 c2p(info->screen_base, image->data, dx, dy, width, height,
2164 par->next_line, par->next_plane, image->width,
2165 info->var.bits_per_pixel);
2166 }
2167 }
2168
2169
2170 /*
2171 * Amiga Frame Buffer Specific ioctls
2172 */
2173
2174 static int amifb_ioctl(struct inode *inode, struct file *file,
2175 unsigned int cmd, unsigned long arg,
2176 struct fb_info *info)
2177 {
2178 union {
2179 struct fb_fix_cursorinfo fix;
2180 struct fb_var_cursorinfo var;
2181 struct fb_cursorstate state;
2182 } crsr;
2183 int i;
2184
2185 switch (cmd) {
2186 case FBIOGET_FCURSORINFO:
2187 i = ami_get_fix_cursorinfo(&crsr.fix);
2188 if (i)
2189 return i;
2190 return copy_to_user((void *)arg, &crsr.fix,
2191 sizeof(crsr.fix)) ? -EFAULT : 0;
2192
2193 case FBIOGET_VCURSORINFO:
2194 i = ami_get_var_cursorinfo(&crsr.var,
2195 ((struct fb_var_cursorinfo *)arg)->data);
2196 if (i)
2197 return i;
2198 return copy_to_user((void *)arg, &crsr.var,
2199 sizeof(crsr.var)) ? -EFAULT : 0;
2200
2201 case FBIOPUT_VCURSORINFO:
2202 if (copy_from_user(&crsr.var, (void *)arg,
2203 sizeof(crsr.var)))
2204 return -EFAULT;
2205 return ami_set_var_cursorinfo(&crsr.var,
2206 ((struct fb_var_cursorinfo *)arg)->data);
2207
2208 case FBIOGET_CURSORSTATE:
2209 i = ami_get_cursorstate(&crsr.state);
2210 if (i)
2211 return i;
2212 return copy_to_user((void *)arg, &crsr.state,
2213 sizeof(crsr.state)) ? -EFAULT : 0;
2214
2215 case FBIOPUT_CURSORSTATE:
2216 if (copy_from_user(&crsr.state, (void *)arg,
2217 sizeof(crsr.state)))
2218 return -EFAULT;
2219 return ami_set_cursorstate(&crsr.state);
2220 }
2221 return -EINVAL;
2222 }
2223
2224
2225 /*
2226 * Allocate, Clear and Align a Block of Chip Memory
2227 */
2228
2229 static u_long unaligned_chipptr = 0;
2230
2231 static inline u_long __init chipalloc(u_long size)
2232 {
2233 size += PAGE_SIZE-1;
2234 if (!(unaligned_chipptr = (u_long)amiga_chip_alloc(size,
2235 "amifb [RAM]")))
2236 panic("No Chip RAM for frame buffer");
2237 memset((void *)unaligned_chipptr, 0, size);
2238 return PAGE_ALIGN(unaligned_chipptr);
2239 }
2240
2241 static inline void chipfree(void)
2242 {
2243 if (unaligned_chipptr)
2244 amiga_chip_free((void *)unaligned_chipptr);
2245 }
2246
2247
2248 /*
2249 * Initialisation
2250 */
2251
2252 int __init amifb_init(void)
2253 {
2254 int tag, i, err = 0;
2255 u_long chipptr;
2256 u_int defmode;
2257
2258 #ifndef MODULE
2259 char *option = NULL;
2260
2261 if (fb_get_options("amifb", &option)) {
2262 amifb_video_off();
2263 return -ENODEV;
2264 }
2265 amifb_setup(option);
2266 #endif
2267 if (!MACH_IS_AMIGA || !AMIGAHW_PRESENT(AMI_VIDEO))
2268 return -ENXIO;
2269
2270 /*
2271 * We request all registers starting from bplpt[0]
2272 */
2273 if (!request_mem_region(CUSTOM_PHYSADDR+0xe0, 0x120,
2274 "amifb [Denise/Lisa]"))
2275 return -EBUSY;
2276
2277 custom.dmacon = DMAF_ALL | DMAF_MASTER;
2278
2279 switch (amiga_chipset) {
2280 #ifdef CONFIG_FB_AMIGA_OCS
2281 case CS_OCS:
2282 strcat(fb_info.fix.id, "OCS");
2283 default_chipset:
2284 chipset = TAG_OCS;
2285 maxdepth[TAG_SHRES] = 0; /* OCS means no SHRES */
2286 maxdepth[TAG_HIRES] = 4;
2287 maxdepth[TAG_LORES] = 6;
2288 maxfmode = TAG_FMODE_1;
2289 defmode = amiga_vblank == 50 ? DEFMODE_PAL
2290 : DEFMODE_NTSC;
2291 fb_info.fix.smem_len = VIDEOMEMSIZE_OCS;
2292 break;
2293 #endif /* CONFIG_FB_AMIGA_OCS */
2294
2295 #ifdef CONFIG_FB_AMIGA_ECS
2296 case CS_ECS:
2297 strcat(fb_info.fix.id, "ECS");
2298 chipset = TAG_ECS;
2299 maxdepth[TAG_SHRES] = 2;
2300 maxdepth[TAG_HIRES] = 4;
2301 maxdepth[TAG_LORES] = 6;
2302 maxfmode = TAG_FMODE_1;
2303 if (AMIGAHW_PRESENT(AMBER_FF))
2304 defmode = amiga_vblank == 50 ? DEFMODE_AMBER_PAL
2305 : DEFMODE_AMBER_NTSC;
2306 else
2307 defmode = amiga_vblank == 50 ? DEFMODE_PAL
2308 : DEFMODE_NTSC;
2309 if (amiga_chip_avail()-CHIPRAM_SAFETY_LIMIT >
2310 VIDEOMEMSIZE_ECS_1M)
2311 fb_info.fix.smem_len = VIDEOMEMSIZE_ECS_2M;
2312 else
2313 fb_info.fix.smem_len = VIDEOMEMSIZE_ECS_1M;
2314 break;
2315 #endif /* CONFIG_FB_AMIGA_ECS */
2316
2317 #ifdef CONFIG_FB_AMIGA_AGA
2318 case CS_AGA:
2319 strcat(fb_info.fix.id, "AGA");
2320 chipset = TAG_AGA;
2321 maxdepth[TAG_SHRES] = 8;
2322 maxdepth[TAG_HIRES] = 8;
2323 maxdepth[TAG_LORES] = 8;
2324 maxfmode = TAG_FMODE_4;
2325 defmode = DEFMODE_AGA;
2326 if (amiga_chip_avail()-CHIPRAM_SAFETY_LIMIT >
2327 VIDEOMEMSIZE_AGA_1M)
2328 fb_info.fix.smem_len = VIDEOMEMSIZE_AGA_2M;
2329 else
2330 fb_info.fix.smem_len = VIDEOMEMSIZE_AGA_1M;
2331 break;
2332 #endif /* CONFIG_FB_AMIGA_AGA */
2333
2334 default:
2335 #ifdef CONFIG_FB_AMIGA_OCS
2336 printk("Unknown graphics chipset, defaulting to OCS\n");
2337 strcat(fb_info.fix.id, "Unknown");
2338 goto default_chipset;
2339 #else /* CONFIG_FB_AMIGA_OCS */
2340 err = -ENXIO;
2341 goto amifb_error;
2342 #endif /* CONFIG_FB_AMIGA_OCS */
2343 break;
2344 }
2345
2346 /*
2347 * Calculate the Pixel Clock Values for this Machine
2348 */
2349
2350 {
2351 u_long tmp = DIVUL(200000000000ULL, amiga_eclock);
2352
2353 pixclock[TAG_SHRES] = (tmp + 4) / 8; /* SHRES: 35 ns / 28 MHz */
2354 pixclock[TAG_HIRES] = (tmp + 2) / 4; /* HIRES: 70 ns / 14 MHz */
2355 pixclock[TAG_LORES] = (tmp + 1) / 2; /* LORES: 140 ns / 7 MHz */
2356 }
2357
2358 /*
2359 * Replace the Tag Values with the Real Pixel Clock Values
2360 */
2361
2362 for (i = 0; i < NUM_TOTAL_MODES; i++) {
2363 struct fb_videomode *mode = &ami_modedb[i];
2364 tag = mode->pixclock;
2365 if (tag == TAG_SHRES || tag == TAG_HIRES || tag == TAG_LORES) {
2366 mode->pixclock = pixclock[tag];
2367 }
2368 }
2369
2370 /*
2371 * These monitor specs are for a typical Amiga monitor (e.g. A1960)
2372 */
2373 if (fb_info.monspecs.hfmin == 0) {
2374 fb_info.monspecs.hfmin = 15000;
2375 fb_info.monspecs.hfmax = 38000;
2376 fb_info.monspecs.vfmin = 49;
2377 fb_info.monspecs.vfmax = 90;
2378 }
2379
2380 fb_info.fbops = &amifb_ops;
2381 fb_info.par = &currentpar;
2382 fb_info.flags = FBINFO_DEFAULT;
2383
2384 if (!fb_find_mode(&fb_info.var, &fb_info, mode_option, ami_modedb,
2385 NUM_TOTAL_MODES, &ami_modedb[defmode], 4)) {
2386 err = -EINVAL;
2387 goto amifb_error;
2388 }
2389
2390 round_down_bpp = 0;
2391 chipptr = chipalloc(fb_info.fix.smem_len+
2392 SPRITEMEMSIZE+
2393 DUMMYSPRITEMEMSIZE+
2394 COPINITSIZE+
2395 4*COPLISTSIZE);
2396
2397 assignchunk(videomemory, u_long, chipptr, fb_info.fix.smem_len);
2398 assignchunk(spritememory, u_long, chipptr, SPRITEMEMSIZE);
2399 assignchunk(dummysprite, u_short *, chipptr, DUMMYSPRITEMEMSIZE);
2400 assignchunk(copdisplay.init, copins *, chipptr, COPINITSIZE);
2401 assignchunk(copdisplay.list[0][0], copins *, chipptr, COPLISTSIZE);
2402 assignchunk(copdisplay.list[0][1], copins *, chipptr, COPLISTSIZE);
2403 assignchunk(copdisplay.list[1][0], copins *, chipptr, COPLISTSIZE);
2404 assignchunk(copdisplay.list[1][1], copins *, chipptr, COPLISTSIZE);
2405
2406 /*
2407 * access the videomem with writethrough cache
2408 */
2409 fb_info.fix.smem_start = (u_long)ZTWO_PADDR(videomemory);
2410 videomemory = (u_long)ioremap_writethrough(fb_info.fix.smem_start,
2411 fb_info.fix.smem_len);
2412 if (!videomemory) {
2413 printk("amifb: WARNING! unable to map videomem cached writethrough\n");
2414 videomemory = ZTWO_VADDR(fb_info.fix.smem_start);
2415 }
2416
2417 fb_info.screen_base = (char *)videomemory;
2418 memset(dummysprite, 0, DUMMYSPRITEMEMSIZE);
2419
2420 /*
2421 * Enable Display DMA
2422 */
2423
2424 custom.dmacon = DMAF_SETCLR | DMAF_MASTER | DMAF_RASTER | DMAF_COPPER |
2425 DMAF_BLITTER | DMAF_SPRITE;
2426
2427 /*
2428 * Make sure the Copper has something to do
2429 */
2430
2431 ami_init_copper();
2432
2433 if (request_irq(IRQ_AMIGA_COPPER, amifb_interrupt, 0,
2434 "fb vertb handler", &currentpar)) {
2435 err = -EBUSY;
2436 goto amifb_error;
2437 }
2438
2439 fb_alloc_cmap(&fb_info.cmap, 1<<fb_info.var.bits_per_pixel, 0);
2440
2441 if (register_framebuffer(&fb_info) < 0) {
2442 err = -EINVAL;
2443 goto amifb_error;
2444 }
2445
2446 printk("fb%d: %s frame buffer device, using %dK of video memory\n",
2447 fb_info.node, fb_info.fix.id, fb_info.fix.smem_len>>10);
2448
2449 return 0;
2450
2451 amifb_error:
2452 amifb_deinit();
2453 return err;
2454 }
2455
2456 static void amifb_deinit(void)
2457 {
2458 fb_dealloc_cmap(&fb_info.cmap);
2459 chipfree();
2460 release_mem_region(CUSTOM_PHYSADDR+0xe0, 0x120);
2461 custom.dmacon = DMAF_ALL | DMAF_MASTER;
2462 }
2463
2464
2465 /*
2466 * Blank the display.
2467 */
2468
2469 static int amifb_blank(int blank, struct fb_info *info)
2470 {
2471 do_blank = blank ? blank : -1;
2472
2473 return 0;
2474 }
2475
2476 /*
2477 * Flash the cursor (called by VBlank interrupt)
2478 */
2479
2480 static int flash_cursor(void)
2481 {
2482 static int cursorcount = 1;
2483
2484 if (cursormode == FB_CURSOR_FLASH) {
2485 if (!--cursorcount) {
2486 cursorstate = -cursorstate;
2487 cursorcount = cursorrate;
2488 if (!is_blanked)
2489 return 1;
2490 }
2491 }
2492 return 0;
2493 }
2494
2495 /*
2496 * VBlank Display Interrupt
2497 */
2498
2499 static irqreturn_t amifb_interrupt(int irq, void *dev_id, struct pt_regs *fp)
2500 {
2501 if (do_vmode_pan || do_vmode_full)
2502 ami_update_display();
2503
2504 if (do_vmode_full)
2505 ami_init_display();
2506
2507 if (do_vmode_pan) {
2508 flash_cursor();
2509 ami_rebuild_copper();
2510 do_cursor = do_vmode_pan = 0;
2511 } else if (do_cursor) {
2512 flash_cursor();
2513 ami_set_sprite();
2514 do_cursor = 0;
2515 } else {
2516 if (flash_cursor())
2517 ami_set_sprite();
2518 }
2519
2520 if (do_blank) {
2521 ami_do_blank();
2522 do_blank = 0;
2523 }
2524
2525 if (do_vmode_full) {
2526 ami_reinit_copper();
2527 do_vmode_full = 0;
2528 }
2529 return IRQ_HANDLED;
2530 }
2531
2532 /* --------------------------- Hardware routines --------------------------- */
2533
2534 /*
2535 * Get the video params out of `var'. If a value doesn't fit, round
2536 * it up, if it's too big, return -EINVAL.
2537 */
2538
2539 static int ami_decode_var(struct fb_var_screeninfo *var,
2540 struct amifb_par *par)
2541 {
2542 u_short clk_shift, line_shift;
2543 u_long maxfetchstop, fstrt, fsize, fconst, xres_n, yres_n;
2544 u_int htotal, vtotal;
2545
2546 /*
2547 * Find a matching Pixel Clock
2548 */
2549
2550 for (clk_shift = TAG_SHRES; clk_shift <= TAG_LORES; clk_shift++)
2551 if (var->pixclock <= pixclock[clk_shift])
2552 break;
2553 if (clk_shift > TAG_LORES) {
2554 DPRINTK("pixclock too high\n");
2555 return -EINVAL;
2556 }
2557 par->clk_shift = clk_shift;
2558
2559 /*
2560 * Check the Geometry Values
2561 */
2562
2563 if ((par->xres = var->xres) < 64)
2564 par->xres = 64;
2565 if ((par->yres = var->yres) < 64)
2566 par->yres = 64;
2567 if ((par->vxres = var->xres_virtual) < par->xres)
2568 par->vxres = par->xres;
2569 if ((par->vyres = var->yres_virtual) < par->yres)
2570 par->vyres = par->yres;
2571
2572 par->bpp = var->bits_per_pixel;
2573 if (!var->nonstd) {
2574 if (par->bpp < 1)
2575 par->bpp = 1;
2576 if (par->bpp > maxdepth[clk_shift]) {
2577 if (round_down_bpp && maxdepth[clk_shift])
2578 par->bpp = maxdepth[clk_shift];
2579 else {
2580 DPRINTK("invalid bpp\n");
2581 return -EINVAL;
2582 }
2583 }
2584 } else if (var->nonstd == FB_NONSTD_HAM) {
2585 if (par->bpp < 6)
2586 par->bpp = 6;
2587 if (par->bpp != 6) {
2588 if (par->bpp < 8)
2589 par->bpp = 8;
2590 if (par->bpp != 8 || !IS_AGA) {
2591 DPRINTK("invalid bpp for ham mode\n");
2592 return -EINVAL;
2593 }
2594 }
2595 } else {
2596 DPRINTK("unknown nonstd mode\n");
2597 return -EINVAL;
2598 }
2599
2600 /*
2601 * FB_VMODE_SMOOTH_XPAN will be cleared, if one of the folloing
2602 * checks failed and smooth scrolling is not possible
2603 */
2604
2605 par->vmode = var->vmode | FB_VMODE_SMOOTH_XPAN;
2606 switch (par->vmode & FB_VMODE_MASK) {
2607 case FB_VMODE_INTERLACED:
2608 line_shift = 0;
2609 break;
2610 case FB_VMODE_NONINTERLACED:
2611 line_shift = 1;
2612 break;
2613 case FB_VMODE_DOUBLE:
2614 if (!IS_AGA) {
2615 DPRINTK("double mode only possible with aga\n");
2616 return -EINVAL;
2617 }
2618 line_shift = 2;
2619 break;
2620 default:
2621 DPRINTK("unknown video mode\n");
2622 return -EINVAL;
2623 break;
2624 }
2625 par->line_shift = line_shift;
2626
2627 /*
2628 * Vertical and Horizontal Timings
2629 */
2630
2631 xres_n = par->xres<<clk_shift;
2632 yres_n = par->yres<<line_shift;
2633 par->htotal = down8((var->left_margin+par->xres+var->right_margin+var->hsync_len)<<clk_shift);
2634 par->vtotal = down2(((var->upper_margin+par->yres+var->lower_margin+var->vsync_len)<<line_shift)+1);
2635
2636 if (IS_AGA)
2637 par->bplcon3 = sprpixmode[clk_shift];
2638 else
2639 par->bplcon3 = 0;
2640 if (var->sync & FB_SYNC_BROADCAST) {
2641 par->diwstop_h = par->htotal-((var->right_margin-var->hsync_len)<<clk_shift);
2642 if (IS_AGA)
2643 par->diwstop_h += mod4(var->hsync_len);
2644 else
2645 par->diwstop_h = down4(par->diwstop_h);
2646
2647 par->diwstrt_h = par->diwstop_h - xres_n;
2648 par->diwstop_v = par->vtotal-((var->lower_margin-var->vsync_len)<<line_shift);
2649 par->diwstrt_v = par->diwstop_v - yres_n;
2650 if (par->diwstop_h >= par->htotal+8) {
2651 DPRINTK("invalid diwstop_h\n");
2652 return -EINVAL;
2653 }
2654 if (par->diwstop_v > par->vtotal) {
2655 DPRINTK("invalid diwstop_v\n");
2656 return -EINVAL;
2657 }
2658
2659 if (!IS_OCS) {
2660 /* Initialize sync with some reasonable values for pwrsave */
2661 par->hsstrt = 160;
2662 par->hsstop = 320;
2663 par->vsstrt = 30;
2664 par->vsstop = 34;
2665 } else {
2666 par->hsstrt = 0;
2667 par->hsstop = 0;
2668 par->vsstrt = 0;
2669 par->vsstop = 0;
2670 }
2671 if (par->vtotal > (PAL_VTOTAL+NTSC_VTOTAL)/2) {
2672 /* PAL video mode */
2673 if (par->htotal != PAL_HTOTAL) {
2674 DPRINTK("htotal invalid for pal\n");
2675 return -EINVAL;
2676 }
2677 if (par->diwstrt_h < PAL_DIWSTRT_H) {
2678 DPRINTK("diwstrt_h too low for pal\n");
2679 return -EINVAL;
2680 }
2681 if (par->diwstrt_v < PAL_DIWSTRT_V) {
2682 DPRINTK("diwstrt_v too low for pal\n");
2683 return -EINVAL;
2684 }
2685 htotal = PAL_HTOTAL>>clk_shift;
2686 vtotal = PAL_VTOTAL>>1;
2687 if (!IS_OCS) {
2688 par->beamcon0 = BMC0_PAL;
2689 par->bplcon3 |= BPC3_BRDRBLNK;
2690 } else if (AMIGAHW_PRESENT(AGNUS_HR_PAL) ||
2691 AMIGAHW_PRESENT(AGNUS_HR_NTSC)) {
2692 par->beamcon0 = BMC0_PAL;
2693 par->hsstop = 1;
2694 } else if (amiga_vblank != 50) {
2695 DPRINTK("pal not supported by this chipset\n");
2696 return -EINVAL;
2697 }
2698 } else {
2699 /* NTSC video mode
2700 * In the AGA chipset seems to be hardware bug with BPC3_BRDRBLNK
2701 * and NTSC activated, so than better let diwstop_h <= 1812
2702 */
2703 if (par->htotal != NTSC_HTOTAL) {
2704 DPRINTK("htotal invalid for ntsc\n");
2705 return -EINVAL;
2706 }
2707 if (par->diwstrt_h < NTSC_DIWSTRT_H) {
2708 DPRINTK("diwstrt_h too low for ntsc\n");
2709 return -EINVAL;
2710 }
2711 if (par->diwstrt_v < NTSC_DIWSTRT_V) {
2712 DPRINTK("diwstrt_v too low for ntsc\n");
2713 return -EINVAL;
2714 }
2715 htotal = NTSC_HTOTAL>>clk_shift;
2716 vtotal = NTSC_VTOTAL>>1;
2717 if (!IS_OCS) {
2718 par->beamcon0 = 0;
2719 par->bplcon3 |= BPC3_BRDRBLNK;
2720 } else if (AMIGAHW_PRESENT(AGNUS_HR_PAL) ||
2721 AMIGAHW_PRESENT(AGNUS_HR_NTSC)) {
2722 par->beamcon0 = 0;
2723 par->hsstop = 1;
2724 } else if (amiga_vblank != 60) {
2725 DPRINTK("ntsc not supported by this chipset\n");
2726 return -EINVAL;
2727 }
2728 }
2729 if (IS_OCS) {
2730 if (par->diwstrt_h >= 1024 || par->diwstop_h < 1024 ||
2731 par->diwstrt_v >= 512 || par->diwstop_v < 256) {
2732 DPRINTK("invalid position for display on ocs\n");
2733 return -EINVAL;
2734 }
2735 }
2736 } else if (!IS_OCS) {
2737 /* Programmable video mode */
2738 par->hsstrt = var->right_margin<<clk_shift;
2739 par->hsstop = (var->right_margin+var->hsync_len)<<clk_shift;
2740 par->diwstop_h = par->htotal - mod8(par->hsstrt) + 8 - (1 << clk_shift);
2741 if (!IS_AGA)
2742 par->diwstop_h = down4(par->diwstop_h) - 16;
2743 par->diwstrt_h = par->diwstop_h - xres_n;
2744 par->hbstop = par->diwstrt_h + 4;
2745 par->hbstrt = par->diwstop_h + 4;
2746 if (par->hbstrt >= par->htotal + 8)
2747 par->hbstrt -= par->htotal;
2748 par->hcenter = par->hsstrt + (par->htotal >> 1);
2749 par->vsstrt = var->lower_margin<<line_shift;
2750 par->vsstop = (var->lower_margin+var->vsync_len)<<line_shift;
2751 par->diwstop_v = par->vtotal;
2752 if ((par->vmode & FB_VMODE_MASK) == FB_VMODE_INTERLACED)
2753 par->diwstop_v -= 2;
2754 par->diwstrt_v = par->diwstop_v - yres_n;
2755 par->vbstop = par->diwstrt_v - 2;
2756 par->vbstrt = par->diwstop_v - 2;
2757 if (par->vtotal > 2048) {
2758 DPRINTK("vtotal too high\n");
2759 return -EINVAL;
2760 }
2761 if (par->htotal > 2048) {
2762 DPRINTK("htotal too high\n");
2763 return -EINVAL;
2764 }
2765 par->bplcon3 |= BPC3_EXTBLKEN;
2766 par->beamcon0 = BMC0_HARDDIS | BMC0_VARVBEN | BMC0_LOLDIS |
2767 BMC0_VARVSYEN | BMC0_VARHSYEN | BMC0_VARBEAMEN |
2768 BMC0_PAL | BMC0_VARCSYEN;
2769 if (var->sync & FB_SYNC_HOR_HIGH_ACT)
2770 par->beamcon0 |= BMC0_HSYTRUE;
2771 if (var->sync & FB_SYNC_VERT_HIGH_ACT)
2772 par->beamcon0 |= BMC0_VSYTRUE;
2773 if (var->sync & FB_SYNC_COMP_HIGH_ACT)
2774 par->beamcon0 |= BMC0_CSYTRUE;
2775 htotal = par->htotal>>clk_shift;
2776 vtotal = par->vtotal>>1;
2777 } else {
2778 DPRINTK("only broadcast modes possible for ocs\n");
2779 return -EINVAL;
2780 }
2781
2782 /*
2783 * Checking the DMA timing
2784 */
2785
2786 fconst = 16<<maxfmode<<clk_shift;
2787
2788 /*
2789 * smallest window start value without turn off other dma cycles
2790 * than sprite1-7, unless you change min_fstrt
2791 */
2792
2793
2794 fsize = ((maxfmode+clk_shift <= 1) ? fconst : 64);
2795 fstrt = downx(fconst, par->diwstrt_h-4) - fsize;
2796 if (fstrt < min_fstrt) {
2797 DPRINTK("fetch start too low\n");
2798 return -EINVAL;
2799 }
2800
2801 /*
2802 * smallest window start value where smooth scrolling is possible
2803 */
2804
2805 fstrt = downx(fconst, par->diwstrt_h-fconst+(1<<clk_shift)-4) - fsize;
2806 if (fstrt < min_fstrt)
2807 par->vmode &= ~FB_VMODE_SMOOTH_XPAN;
2808
2809 maxfetchstop = down16(par->htotal - 80);
2810
2811 fstrt = downx(fconst, par->diwstrt_h-4) - 64 - fconst;
2812 fsize = upx(fconst, xres_n + modx(fconst, downx(1<<clk_shift, par->diwstrt_h-4)));
2813 if (fstrt + fsize > maxfetchstop)
2814 par->vmode &= ~FB_VMODE_SMOOTH_XPAN;
2815
2816 fsize = upx(fconst, xres_n);
2817 if (fstrt + fsize > maxfetchstop) {
2818 DPRINTK("fetch stop too high\n");
2819 return -EINVAL;
2820 }
2821
2822 if (maxfmode + clk_shift <= 1) {
2823 fsize = up64(xres_n + fconst - 1);
2824 if (min_fstrt + fsize - 64 > maxfetchstop)
2825 par->vmode &= ~FB_VMODE_SMOOTH_XPAN;
2826
2827 fsize = up64(xres_n);
2828 if (min_fstrt + fsize - 64 > maxfetchstop) {
2829 DPRINTK("fetch size too high\n");
2830 return -EINVAL;
2831 }
2832
2833 fsize -= 64;
2834 } else
2835 fsize -= fconst;
2836
2837 /*
2838 * Check if there is enough time to update the bitplane pointers for ywrap
2839 */
2840
2841 if (par->htotal-fsize-64 < par->bpp*64)
2842 par->vmode &= ~FB_VMODE_YWRAP;
2843
2844 /*
2845 * Bitplane calculations and check the Memory Requirements
2846 */
2847
2848 if (amifb_ilbm) {
2849 par->next_plane = div8(upx(16<<maxfmode, par->vxres));
2850 par->next_line = par->bpp*par->next_plane;
2851 if (par->next_line * par->vyres > fb_info.fix.smem_len) {
2852 DPRINTK("too few video mem\n");
2853 return -EINVAL;
2854 }
2855 } else {
2856 par->next_line = div8(upx(16<<maxfmode, par->vxres));
2857 par->next_plane = par->vyres*par->next_line;
2858 if (par->next_plane * par->bpp > fb_info.fix.smem_len) {
2859 DPRINTK("too few video mem\n");
2860 return -EINVAL;
2861 }
2862 }
2863
2864 /*
2865 * Hardware Register Values
2866 */
2867
2868 par->bplcon0 = BPC0_COLOR | bplpixmode[clk_shift];
2869 if (!IS_OCS)
2870 par->bplcon0 |= BPC0_ECSENA;
2871 if (par->bpp == 8)
2872 par->bplcon0 |= BPC0_BPU3;
2873 else
2874 par->bplcon0 |= par->bpp<<12;
2875 if (var->nonstd == FB_NONSTD_HAM)
2876 par->bplcon0 |= BPC0_HAM;
2877 if (var->sync & FB_SYNC_EXT)
2878 par->bplcon0 |= BPC0_ERSY;
2879
2880 if (IS_AGA)
2881 par->fmode = bplfetchmode[maxfmode];
2882
2883 switch (par->vmode & FB_VMODE_MASK) {
2884 case FB_VMODE_INTERLACED:
2885 par->bplcon0 |= BPC0_LACE;
2886 break;
2887 case FB_VMODE_DOUBLE:
2888 if (IS_AGA)
2889 par->fmode |= FMODE_SSCAN2 | FMODE_BSCAN2;
2890 break;
2891 }
2892
2893 if (!((par->vmode ^ var->vmode) & FB_VMODE_YWRAP)) {
2894 par->xoffset = var->xoffset;
2895 par->yoffset = var->yoffset;
2896 if (par->vmode & FB_VMODE_YWRAP) {
2897 if (par->xoffset || par->yoffset < 0 || par->yoffset >= par->vyres)
2898 par->xoffset = par->yoffset = 0;
2899 } else {
2900 if (par->xoffset < 0 || par->xoffset > upx(16<<maxfmode, par->vxres-par->xres) ||
2901 par->yoffset < 0 || par->yoffset > par->vyres-par->yres)
2902 par->xoffset = par->yoffset = 0;
2903 }
2904 } else
2905 par->xoffset = par->yoffset = 0;
2906
2907 par->crsr.crsr_x = par->crsr.crsr_y = 0;
2908 par->crsr.spot_x = par->crsr.spot_y = 0;
2909 par->crsr.height = par->crsr.width = 0;
2910
2911 #if 0 /* fbmon not done. uncomment for 2.5.x -brad */
2912 if (!fbmon_valid_timings(pixclock[clk_shift], htotal, vtotal,
2913 &fb_info)) {
2914 DPRINTK("mode doesn't fit for monitor\n");
2915 return -EINVAL;
2916 }
2917 #endif
2918
2919 return 0;
2920 }
2921
2922 /*
2923 * Fill the `var' structure based on the values in `par' and maybe
2924 * other values read out of the hardware.
2925 */
2926
2927 static int ami_encode_var(struct fb_var_screeninfo *var,
2928 struct amifb_par *par)
2929 {
2930 u_short clk_shift, line_shift;
2931
2932 memset(var, 0, sizeof(struct fb_var_screeninfo));
2933
2934 clk_shift = par->clk_shift;
2935 line_shift = par->line_shift;
2936
2937 var->xres = par->xres;
2938 var->yres = par->yres;
2939 var->xres_virtual = par->vxres;
2940 var->yres_virtual = par->vyres;
2941 var->xoffset = par->xoffset;
2942 var->yoffset = par->yoffset;
2943
2944 var->bits_per_pixel = par->bpp;
2945 var->grayscale = 0;
2946
2947 var->red.offset = 0;
2948 var->red.msb_right = 0;
2949 var->red.length = par->bpp;
2950 if (par->bplcon0 & BPC0_HAM)
2951 var->red.length -= 2;
2952 var->blue = var->green = var->red;
2953 var->transp.offset = 0;
2954 var->transp.length = 0;
2955 var->transp.msb_right = 0;
2956
2957 if (par->bplcon0 & BPC0_HAM)
2958 var->nonstd = FB_NONSTD_HAM;
2959 else
2960 var->nonstd = 0;
2961 var->activate = 0;
2962
2963 var->height = -1;
2964 var->width = -1;
2965
2966 var->pixclock = pixclock[clk_shift];
2967
2968 if (IS_AGA && par->fmode & FMODE_BSCAN2)
2969 var->vmode = FB_VMODE_DOUBLE;
2970 else if (par->bplcon0 & BPC0_LACE)
2971 var->vmode = FB_VMODE_INTERLACED;
2972 else
2973 var->vmode = FB_VMODE_NONINTERLACED;
2974
2975 if (!IS_OCS && par->beamcon0 & BMC0_VARBEAMEN) {
2976 var->hsync_len = (par->hsstop-par->hsstrt)>>clk_shift;
2977 var->right_margin = par->hsstrt>>clk_shift;
2978 var->left_margin = (par->htotal>>clk_shift) - var->xres - var->right_margin - var->hsync_len;
2979 var->vsync_len = (par->vsstop-par->vsstrt)>>line_shift;
2980 var->lower_margin = par->vsstrt>>line_shift;
2981 var->upper_margin = (par->vtotal>>line_shift) - var->yres - var->lower_margin - var->vsync_len;
2982 var->sync = 0;
2983 if (par->beamcon0 & BMC0_HSYTRUE)
2984 var->sync |= FB_SYNC_HOR_HIGH_ACT;
2985 if (par->beamcon0 & BMC0_VSYTRUE)
2986 var->sync |= FB_SYNC_VERT_HIGH_ACT;
2987 if (par->beamcon0 & BMC0_CSYTRUE)
2988 var->sync |= FB_SYNC_COMP_HIGH_ACT;
2989 } else {
2990 var->sync = FB_SYNC_BROADCAST;
2991 var->hsync_len = (152>>clk_shift) + mod4(par->diwstop_h);
2992 var->right_margin = ((par->htotal - down4(par->diwstop_h))>>clk_shift) + var->hsync_len;
2993 var->left_margin = (par->htotal>>clk_shift) - var->xres - var->right_margin - var->hsync_len;
2994 var->vsync_len = 4>>line_shift;
2995 var->lower_margin = ((par->vtotal - par->diwstop_v)>>line_shift) + var->vsync_len;
2996 var->upper_margin = (((par->vtotal - 2)>>line_shift) + 1) - var->yres -
2997 var->lower_margin - var->vsync_len;
2998 }
2999
3000 if (par->bplcon0 & BPC0_ERSY)
3001 var->sync |= FB_SYNC_EXT;
3002 if (par->vmode & FB_VMODE_YWRAP)
3003 var->vmode |= FB_VMODE_YWRAP;
3004
3005 return 0;
3006 }
3007
3008
3009 /*
3010 * Pan or Wrap the Display
3011 *
3012 * This call looks only at xoffset, yoffset and the FB_VMODE_YWRAP flag
3013 * in `var'.
3014 */
3015
3016 static void ami_pan_var(struct fb_var_screeninfo *var)
3017 {
3018 struct amifb_par *par = &currentpar;
3019
3020 par->xoffset = var->xoffset;
3021 par->yoffset = var->yoffset;
3022 if (var->vmode & FB_VMODE_YWRAP)
3023 par->vmode |= FB_VMODE_YWRAP;
3024 else
3025 par->vmode &= ~FB_VMODE_YWRAP;
3026
3027 do_vmode_pan = 0;
3028 ami_update_par();
3029 do_vmode_pan = 1;
3030 }
3031
3032 /*
3033 * Update hardware
3034 */
3035
3036 static int ami_update_par(void)
3037 {
3038 struct amifb_par *par = &currentpar;
3039 short clk_shift, vshift, fstrt, fsize, fstop, fconst, shift, move, mod;
3040
3041 clk_shift = par->clk_shift;
3042
3043 if (!(par->vmode & FB_VMODE_SMOOTH_XPAN))
3044 par->xoffset = upx(16<<maxfmode, par->xoffset);
3045
3046 fconst = 16<<maxfmode<<clk_shift;
3047 vshift = modx(16<<maxfmode, par->xoffset);
3048 fstrt = par->diwstrt_h - (vshift<<clk_shift) - 4;
3049 fsize = (par->xres+vshift)<<clk_shift;
3050 shift = modx(fconst, fstrt);
3051 move = downx(2<<maxfmode, div8(par->xoffset));
3052 if (maxfmode + clk_shift > 1) {
3053 fstrt = downx(fconst, fstrt) - 64;
3054 fsize = upx(fconst, fsize);
3055 fstop = fstrt + fsize - fconst;
3056 } else {
3057 mod = fstrt = downx(fconst, fstrt) - fconst;
3058 fstop = fstrt + upx(fconst, fsize) - 64;
3059 fsize = up64(fsize);
3060 fstrt = fstop - fsize + 64;
3061 if (fstrt < min_fstrt) {
3062 fstop += min_fstrt - fstrt;
3063 fstrt = min_fstrt;
3064 }
3065 move = move - div8((mod-fstrt)>>clk_shift);
3066 }
3067 mod = par->next_line - div8(fsize>>clk_shift);
3068 par->ddfstrt = fstrt;
3069 par->ddfstop = fstop;
3070 par->bplcon1 = hscroll2hw(shift);
3071 par->bpl2mod = mod;
3072 if (par->bplcon0 & BPC0_LACE)
3073 par->bpl2mod += par->next_line;
3074 if (IS_AGA && (par->fmode & FMODE_BSCAN2))
3075 par->bpl1mod = -div8(fsize>>clk_shift);
3076 else
3077 par->bpl1mod = par->bpl2mod;
3078
3079 if (par->yoffset) {
3080 par->bplpt0 = fb_info.fix.smem_start + par->next_line*par->yoffset + move;
3081 if (par->vmode & FB_VMODE_YWRAP) {
3082 if (par->yoffset > par->vyres-par->yres) {
3083 par->bplpt0wrap = fb_info.fix.smem_start + move;
3084 if (par->bplcon0 & BPC0_LACE && mod2(par->diwstrt_v+par->vyres-par->yoffset))
3085 par->bplpt0wrap += par->next_line;
3086 }
3087 }
3088 } else
3089 par->bplpt0 = fb_info.fix.smem_start + move;
3090
3091 if (par->bplcon0 & BPC0_LACE && mod2(par->diwstrt_v))
3092 par->bplpt0 += par->next_line;
3093
3094 return 0;
3095 }
3096
3097
3098 /*
3099 * Set a single color register. The values supplied are already
3100 * rounded down to the hardware's capabilities (according to the
3101 * entries in the var structure). Return != 0 for invalid regno.
3102 */
3103
3104 static int amifb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
3105 u_int transp, struct fb_info *info)
3106 {
3107 if (IS_AGA) {
3108 if (regno > 255)
3109 return 1;
3110 } else if (currentpar.bplcon0 & BPC0_SHRES) {
3111 if (regno > 3)
3112 return 1;
3113 } else {
3114 if (regno > 31)
3115 return 1;
3116 }
3117 red >>= 8;
3118 green >>= 8;
3119 blue >>= 8;
3120 if (!regno) {
3121 red0 = red;
3122 green0 = green;
3123 blue0 = blue;
3124 }
3125
3126 /*
3127 * Update the corresponding Hardware Color Register, unless it's Color
3128 * Register 0 and the screen is blanked.
3129 *
3130 * VBlank is switched off to protect bplcon3 or ecs_palette[] from
3131 * being changed by ami_do_blank() during the VBlank.
3132 */
3133
3134 if (regno || !is_blanked) {
3135 #if defined(CONFIG_FB_AMIGA_AGA)
3136 if (IS_AGA) {
3137 u_short bplcon3 = currentpar.bplcon3;
3138 VBlankOff();
3139 custom.bplcon3 = bplcon3 | (regno<<8 & 0xe000);
3140 custom.color[regno&31] = rgb2hw8_high(red, green, blue);
3141 custom.bplcon3 = bplcon3 | (regno<<8 & 0xe000) | BPC3_LOCT;
3142 custom.color[regno&31] = rgb2hw8_low(red, green, blue);
3143 custom.bplcon3 = bplcon3;
3144 VBlankOn();
3145 } else
3146 #endif
3147 #if defined(CONFIG_FB_AMIGA_ECS)
3148 if (currentpar.bplcon0 & BPC0_SHRES) {
3149 u_short color, mask;
3150 int i;
3151
3152 mask = 0x3333;
3153 color = rgb2hw2(red, green, blue);
3154 VBlankOff();
3155 for (i = regno+12; i >= (int)regno; i -= 4)
3156 custom.color[i] = ecs_palette[i] = (ecs_palette[i] & mask) | color;
3157 mask <<=2; color >>= 2;
3158 regno = down16(regno)+mul4(mod4(regno));
3159 for (i = regno+3; i >= (int)regno; i--)
3160 custom.color[i] = ecs_palette[i] = (ecs_palette[i] & mask) | color;
3161 VBlankOn();
3162 } else
3163 #endif
3164 custom.color[regno] = rgb2hw4(red, green, blue);
3165 }
3166 return 0;
3167 }
3168
3169 static void ami_update_display(void)
3170 {
3171 struct amifb_par *par = &currentpar;
3172
3173 custom.bplcon1 = par->bplcon1;
3174 custom.bpl1mod = par->bpl1mod;
3175 custom.bpl2mod = par->bpl2mod;
3176 custom.ddfstrt = ddfstrt2hw(par->ddfstrt);
3177 custom.ddfstop = ddfstop2hw(par->ddfstop);
3178 }
3179
3180 /*
3181 * Change the video mode (called by VBlank interrupt)
3182 */
3183
3184 static void ami_init_display(void)
3185 {
3186 struct amifb_par *par = &currentpar;
3187 int i;
3188
3189 custom.bplcon0 = par->bplcon0 & ~BPC0_LACE;
3190 custom.bplcon2 = (IS_OCS ? 0 : BPC2_KILLEHB) | BPC2_PF2P2 | BPC2_PF1P2;
3191 if (!IS_OCS) {
3192 custom.bplcon3 = par->bplcon3;
3193 if (IS_AGA)
3194 custom.bplcon4 = BPC4_ESPRM4 | BPC4_OSPRM4;
3195 if (par->beamcon0 & BMC0_VARBEAMEN) {
3196 custom.htotal = htotal2hw(par->htotal);
3197 custom.hbstrt = hbstrt2hw(par->hbstrt);
3198 custom.hbstop = hbstop2hw(par->hbstop);
3199 custom.hsstrt = hsstrt2hw(par->hsstrt);
3200 custom.hsstop = hsstop2hw(par->hsstop);
3201 custom.hcenter = hcenter2hw(par->hcenter);
3202 custom.vtotal = vtotal2hw(par->vtotal);
3203 custom.vbstrt = vbstrt2hw(par->vbstrt);
3204 custom.vbstop = vbstop2hw(par->vbstop);
3205 custom.vsstrt = vsstrt2hw(par->vsstrt);
3206 custom.vsstop = vsstop2hw(par->vsstop);
3207 }
3208 }
3209 if (!IS_OCS || par->hsstop)
3210 custom.beamcon0 = par->beamcon0;
3211 if (IS_AGA)
3212 custom.fmode = par->fmode;
3213
3214 /*
3215 * The minimum period for audio depends on htotal
3216 */
3217
3218 amiga_audio_min_period = div16(par->htotal);
3219
3220 is_lace = par->bplcon0 & BPC0_LACE ? 1 : 0;
3221 #if 1
3222 if (is_lace) {
3223 i = custom.vposr >> 15;
3224 } else {
3225 custom.vposw = custom.vposr | 0x8000;
3226 i = 1;
3227 }
3228 #else
3229 i = 1;
3230 custom.vposw = custom.vposr | 0x8000;
3231 #endif
3232 custom.cop2lc = (u_short *)ZTWO_PADDR(copdisplay.list[currentcop][i]);
3233 }
3234
3235 /*
3236 * (Un)Blank the screen (called by VBlank interrupt)
3237 */
3238
3239 static void ami_do_blank(void)
3240 {
3241 struct amifb_par *par = &currentpar;
3242 #if defined(CONFIG_FB_AMIGA_AGA)
3243 u_short bplcon3 = par->bplcon3;
3244 #endif
3245 u_char red, green, blue;
3246
3247 if (do_blank > 0) {
3248 custom.dmacon = DMAF_RASTER | DMAF_SPRITE;
3249 red = green = blue = 0;
3250 if (!IS_OCS && do_blank > 1) {
3251 switch (do_blank) {
3252 case FB_BLANK_VSYNC_SUSPEND:
3253 custom.hsstrt = hsstrt2hw(par->hsstrt);
3254 custom.hsstop = hsstop2hw(par->hsstop);
3255 custom.vsstrt = vsstrt2hw(par->vtotal+4);
3256 custom.vsstop = vsstop2hw(par->vtotal+4);
3257 break;
3258 case FB_BLANK_HSYNC_SUSPEND:
3259 custom.hsstrt = hsstrt2hw(par->htotal+16);
3260 custom.hsstop = hsstop2hw(par->htotal+16);
3261 custom.vsstrt = vsstrt2hw(par->vsstrt);
3262 custom.vsstop = vsstrt2hw(par->vsstop);
3263 break;
3264 case FB_BLANK_POWERDOWN:
3265 custom.hsstrt = hsstrt2hw(par->htotal+16);
3266 custom.hsstop = hsstop2hw(par->htotal+16);
3267 custom.vsstrt = vsstrt2hw(par->vtotal+4);
3268 custom.vsstop = vsstop2hw(par->vtotal+4);
3269 break;
3270 }
3271 if (!(par->beamcon0 & BMC0_VARBEAMEN)) {
3272 custom.htotal = htotal2hw(par->htotal);
3273 custom.vtotal = vtotal2hw(par->vtotal);
3274 custom.beamcon0 = BMC0_HARDDIS | BMC0_VARBEAMEN |
3275 BMC0_VARVSYEN | BMC0_VARHSYEN | BMC0_VARCSYEN;
3276 }
3277 }
3278 } else {
3279 custom.dmacon = DMAF_SETCLR | DMAF_RASTER | DMAF_SPRITE;
3280 red = red0;
3281 green = green0;
3282 blue = blue0;
3283 if (!IS_OCS) {
3284 custom.hsstrt = hsstrt2hw(par->hsstrt);
3285 custom.hsstop = hsstop2hw(par->hsstop);
3286 custom.vsstrt = vsstrt2hw(par->vsstrt);
3287 custom.vsstop = vsstop2hw(par->vsstop);
3288 custom.beamcon0 = par->beamcon0;
3289 }
3290 }
3291 #if defined(CONFIG_FB_AMIGA_AGA)
3292 if (IS_AGA) {
3293 custom.bplcon3 = bplcon3;
3294 custom.color[0] = rgb2hw8_high(red, green, blue);
3295 custom.bplcon3 = bplcon3 | BPC3_LOCT;
3296 custom.color[0] = rgb2hw8_low(red, green, blue);
3297 custom.bplcon3 = bplcon3;
3298 } else
3299 #endif
3300 #if defined(CONFIG_FB_AMIGA_ECS)
3301 if (par->bplcon0 & BPC0_SHRES) {
3302 u_short color, mask;
3303 int i;
3304
3305 mask = 0x3333;
3306 color = rgb2hw2(red, green, blue);
3307 for (i = 12; i >= 0; i -= 4)
3308 custom.color[i] = ecs_palette[i] = (ecs_palette[i] & mask) | color;
3309 mask <<=2; color >>= 2;
3310 for (i = 3; i >= 0; i--)
3311 custom.color[i] = ecs_palette[i] = (ecs_palette[i] & mask) | color;
3312 } else
3313 #endif
3314 custom.color[0] = rgb2hw4(red, green, blue);
3315 is_blanked = do_blank > 0 ? do_blank : 0;
3316 }
3317
3318 static int ami_get_fix_cursorinfo(struct fb_fix_cursorinfo *fix)
3319 {
3320 struct amifb_par *par = &currentpar;
3321
3322 fix->crsr_width = fix->crsr_xsize = par->crsr.width;
3323 fix->crsr_height = fix->crsr_ysize = par->crsr.height;
3324 fix->crsr_color1 = 17;
3325 fix->crsr_color2 = 18;
3326 return 0;
3327 }
3328
3329 static int ami_get_var_cursorinfo(struct fb_var_cursorinfo *var, u_char *data)
3330 {
3331 struct amifb_par *par = &currentpar;
3332 register u_short *lspr, *sspr;
3333 #ifdef __mc68000__
3334 register u_long datawords asm ("d2");
3335 #else
3336 register u_long datawords;
3337 #endif
3338 register short delta;
3339 register u_char color;
3340 short height, width, bits, words;
3341 int size, alloc;
3342
3343 size = par->crsr.height*par->crsr.width;
3344 alloc = var->height*var->width;
3345 var->height = par->crsr.height;
3346 var->width = par->crsr.width;
3347 var->xspot = par->crsr.spot_x;
3348 var->yspot = par->crsr.spot_y;
3349 if (size > var->height*var->width)
3350 return -ENAMETOOLONG;
3351 if (!access_ok(VERIFY_WRITE, (void *)data, size))
3352 return -EFAULT;
3353 delta = 1<<par->crsr.fmode;
3354 lspr = lofsprite + (delta<<1);
3355 if (par->bplcon0 & BPC0_LACE)
3356 sspr = shfsprite + (delta<<1);
3357 else
3358 sspr = 0;
3359 for (height = (short)var->height-1; height >= 0; height--) {
3360 bits = 0; words = delta; datawords = 0;
3361 for (width = (short)var->width-1; width >= 0; width--) {
3362 if (bits == 0) {
3363 bits = 16; --words;
3364 #ifdef __mc68000__
3365 asm volatile ("movew %1@(%3:w:2),%0 ; swap %0 ; movew %1@+,%0"
3366 : "=d" (datawords), "=a" (lspr) : "1" (lspr), "d" (delta));
3367 #else
3368 datawords = (*(lspr+delta) << 16) | (*lspr++);
3369 #endif
3370 }
3371 --bits;
3372 #ifdef __mc68000__
3373 asm volatile (
3374 "clrb %0 ; swap %1 ; lslw #1,%1 ; roxlb #1,%0 ; "
3375 "swap %1 ; lslw #1,%1 ; roxlb #1,%0"
3376 : "=d" (color), "=d" (datawords) : "1" (datawords));
3377 #else
3378 color = (((datawords >> 30) & 2)
3379 | ((datawords >> 15) & 1));
3380 datawords <<= 1;
3381 #endif
3382 put_user(color, data++);
3383 }
3384 if (bits > 0) {
3385 --words; ++lspr;
3386 }
3387 while (--words >= 0)
3388 ++lspr;
3389 #ifdef __mc68000__
3390 asm volatile ("lea %0@(%4:w:2),%0 ; tstl %1 ; jeq 1f ; exg %0,%1\n1:"
3391 : "=a" (lspr), "=a" (sspr) : "0" (lspr), "1" (sspr), "d" (delta));
3392 #else
3393 lspr += delta;
3394 if (sspr) {
3395 u_short *tmp = lspr;
3396 lspr = sspr;
3397 sspr = tmp;
3398 }
3399 #endif
3400 }
3401 return 0;
3402 }
3403
3404 static int ami_set_var_cursorinfo(struct fb_var_cursorinfo *var, u_char *data)
3405 {
3406 struct amifb_par *par = &currentpar;
3407 register u_short *lspr, *sspr;
3408 #ifdef __mc68000__
3409 register u_long datawords asm ("d2");
3410 #else
3411 register u_long datawords;
3412 #endif
3413 register short delta;
3414 u_short fmode;
3415 short height, width, bits, words;
3416
3417 if (!var->width)
3418 return -EINVAL;
3419 else if (var->width <= 16)
3420 fmode = TAG_FMODE_1;
3421 else if (var->width <= 32)
3422 fmode = TAG_FMODE_2;
3423 else if (var->width <= 64)
3424 fmode = TAG_FMODE_4;
3425 else
3426 return -EINVAL;
3427 if (fmode > maxfmode)
3428 return -EINVAL;
3429 if (!var->height)
3430 return -EINVAL;
3431 if (!access_ok(VERIFY_READ, (void *)data, var->width*var->height))
3432 return -EFAULT;
3433 delta = 1<<fmode;
3434 lofsprite = shfsprite = (u_short *)spritememory;
3435 lspr = lofsprite + (delta<<1);
3436 if (par->bplcon0 & BPC0_LACE) {
3437 if (((var->height+4)<<fmode<<2) > SPRITEMEMSIZE)
3438 return -EINVAL;
3439 memset(lspr, 0, (var->height+4)<<fmode<<2);
3440 shfsprite += ((var->height+5)&-2)<<fmode;
3441 sspr = shfsprite + (delta<<1);
3442 } else {
3443 if (((var->height+2)<<fmode<<2) > SPRITEMEMSIZE)
3444 return -EINVAL;
3445 memset(lspr, 0, (var->height+2)<<fmode<<2);
3446 sspr = 0;
3447 }
3448 for (height = (short)var->height-1; height >= 0; height--) {
3449 bits = 16; words = delta; datawords = 0;
3450 for (width = (short)var->width-1; width >= 0; width--) {
3451 unsigned long tdata = 0;
3452 get_user(tdata, (char *)data);
3453 data++;
3454 #ifdef __mc68000__
3455 asm volatile (
3456 "lsrb #1,%2 ; roxlw #1,%0 ; swap %0 ; "
3457 "lsrb #1,%2 ; roxlw #1,%0 ; swap %0"
3458 : "=d" (datawords)
3459 : "0" (datawords), "d" (tdata));
3460 #else
3461 datawords = ((datawords << 1) & 0xfffefffe);
3462 datawords |= tdata & 1;
3463 datawords |= (tdata & 2) << (16-1);
3464 #endif
3465 if (--bits == 0) {
3466 bits = 16; --words;
3467 #ifdef __mc68000__
3468 asm volatile ("swap %2 ; movew %2,%0@(%3:w:2) ; swap %2 ; movew %2,%0@+"
3469 : "=a" (lspr) : "0" (lspr), "d" (datawords), "d" (delta));
3470 #else
3471 *(lspr+delta) = (u_short) (datawords >> 16);
3472 *lspr++ = (u_short) (datawords & 0xffff);
3473 #endif
3474 }
3475 }
3476 if (bits < 16) {
3477 --words;
3478 #ifdef __mc68000__
3479 asm volatile (
3480 "swap %2 ; lslw %4,%2 ; movew %2,%0@(%3:w:2) ; "
3481 "swap %2 ; lslw %4,%2 ; movew %2,%0@+"
3482 : "=a" (lspr) : "0" (lspr), "d" (datawords), "d" (delta), "d" (bits));
3483 #else
3484 *(lspr+delta) = (u_short) (datawords >> (16+bits));
3485 *lspr++ = (u_short) ((datawords & 0x0000ffff) >> bits);
3486 #endif
3487 }
3488 while (--words >= 0) {
3489 #ifdef __mc68000__
3490 asm volatile ("moveql #0,%%d0 ; movew %%d0,%0@(%2:w:2) ; movew %%d0,%0@+"
3491 : "=a" (lspr) : "0" (lspr), "d" (delta) : "d0");
3492 #else
3493 *(lspr+delta) = 0;
3494 *lspr++ = 0;
3495 #endif
3496 }
3497 #ifdef __mc68000__
3498 asm volatile ("lea %0@(%4:w:2),%0 ; tstl %1 ; jeq 1f ; exg %0,%1\n1:"
3499 : "=a" (lspr), "=a" (sspr) : "0" (lspr), "1" (sspr), "d" (delta));
3500 #else
3501 lspr += delta;
3502 if (sspr) {
3503 u_short *tmp = lspr;
3504 lspr = sspr;
3505 sspr = tmp;
3506 }
3507 #endif
3508 }
3509 par->crsr.height = var->height;
3510 par->crsr.width = var->width;
3511 par->crsr.spot_x = var->xspot;
3512 par->crsr.spot_y = var->yspot;
3513 par->crsr.fmode = fmode;
3514 if (IS_AGA) {
3515 par->fmode &= ~(FMODE_SPAGEM | FMODE_SPR32);
3516 par->fmode |= sprfetchmode[fmode];
3517 custom.fmode = par->fmode;
3518 }
3519 return 0;
3520 }
3521
3522 static int ami_get_cursorstate(struct fb_cursorstate *state)
3523 {
3524 struct amifb_par *par = &currentpar;
3525
3526 state->xoffset = par->crsr.crsr_x;
3527 state->yoffset = par->crsr.crsr_y;
3528 state->mode = cursormode;
3529 return 0;
3530 }
3531
3532 static int ami_set_cursorstate(struct fb_cursorstate *state)
3533 {
3534 struct amifb_par *par = &currentpar;
3535
3536 par->crsr.crsr_x = state->xoffset;
3537 par->crsr.crsr_y = state->yoffset;
3538 if ((cursormode = state->mode) == FB_CURSOR_OFF)
3539 cursorstate = -1;
3540 do_cursor = 1;
3541 return 0;
3542 }
3543
3544 static void ami_set_sprite(void)
3545 {
3546 struct amifb_par *par = &currentpar;
3547 copins *copl, *cops;
3548 u_short hs, vs, ve;
3549 u_long pl, ps, pt;
3550 short mx, my;
3551
3552 cops = copdisplay.list[currentcop][0];
3553 copl = copdisplay.list[currentcop][1];
3554 ps = pl = ZTWO_PADDR(dummysprite);
3555 mx = par->crsr.crsr_x-par->crsr.spot_x;
3556 my = par->crsr.crsr_y-par->crsr.spot_y;
3557 if (!(par->vmode & FB_VMODE_YWRAP)) {
3558 mx -= par->xoffset;
3559 my -= par->yoffset;
3560 }
3561 if (!is_blanked && cursorstate > 0 && par->crsr.height > 0 &&
3562 mx > -(short)par->crsr.width && mx < par->xres &&
3563 my > -(short)par->crsr.height && my < par->yres) {
3564 pl = ZTWO_PADDR(lofsprite);
3565 hs = par->diwstrt_h + (mx<<par->clk_shift) - 4;
3566 vs = par->diwstrt_v + (my<<par->line_shift);
3567 ve = vs + (par->crsr.height<<par->line_shift);
3568 if (par->bplcon0 & BPC0_LACE) {
3569 ps = ZTWO_PADDR(shfsprite);
3570 lofsprite[0] = spr2hw_pos(vs, hs);
3571 shfsprite[0] = spr2hw_pos(vs+1, hs);
3572 if (mod2(vs)) {
3573 lofsprite[1<<par->crsr.fmode] = spr2hw_ctl(vs, hs, ve);
3574 shfsprite[1<<par->crsr.fmode] = spr2hw_ctl(vs+1, hs, ve+1);
3575 pt = pl; pl = ps; ps = pt;
3576 } else {
3577 lofsprite[1<<par->crsr.fmode] = spr2hw_ctl(vs, hs, ve+1);
3578 shfsprite[1<<par->crsr.fmode] = spr2hw_ctl(vs+1, hs, ve);
3579 }
3580 } else {
3581 lofsprite[0] = spr2hw_pos(vs, hs) | (IS_AGA && (par->fmode & FMODE_BSCAN2) ? 0x80 : 0);
3582 lofsprite[1<<par->crsr.fmode] = spr2hw_ctl(vs, hs, ve);
3583 }
3584 }
3585 copl[cop_spr0ptrh].w[1] = highw(pl);
3586 copl[cop_spr0ptrl].w[1] = loww(pl);
3587 if (par->bplcon0 & BPC0_LACE) {
3588 cops[cop_spr0ptrh].w[1] = highw(ps);
3589 cops[cop_spr0ptrl].w[1] = loww(ps);
3590 }
3591 }
3592
3593
3594 /*
3595 * Initialise the Copper Initialisation List
3596 */
3597
3598 static void __init ami_init_copper(void)
3599 {
3600 copins *cop = copdisplay.init;
3601 u_long p;
3602 int i;
3603
3604 if (!IS_OCS) {
3605 (cop++)->l = CMOVE(BPC0_COLOR | BPC0_SHRES | BPC0_ECSENA, bplcon0);
3606 (cop++)->l = CMOVE(0x0181, diwstrt);
3607 (cop++)->l = CMOVE(0x0281, diwstop);
3608 (cop++)->l = CMOVE(0x0000, diwhigh);
3609 } else
3610 (cop++)->l = CMOVE(BPC0_COLOR, bplcon0);
3611 p = ZTWO_PADDR(dummysprite);
3612 for (i = 0; i < 8; i++) {
3613 (cop++)->l = CMOVE(0, spr[i].pos);
3614 (cop++)->l = CMOVE(highw(p), sprpt[i]);
3615 (cop++)->l = CMOVE2(loww(p), sprpt[i]);
3616 }
3617
3618 (cop++)->l = CMOVE(IF_SETCLR | IF_COPER, intreq);
3619 copdisplay.wait = cop;
3620 (cop++)->l = CEND;
3621 (cop++)->l = CMOVE(0, copjmp2);
3622 cop->l = CEND;
3623
3624 custom.cop1lc = (u_short *)ZTWO_PADDR(copdisplay.init);
3625 custom.copjmp1 = 0;
3626 }
3627
3628 static void ami_reinit_copper(void)
3629 {
3630 struct amifb_par *par = &currentpar;
3631
3632 copdisplay.init[cip_bplcon0].w[1] = ~(BPC0_BPU3 | BPC0_BPU2 | BPC0_BPU1 | BPC0_BPU0) & par->bplcon0;
3633 copdisplay.wait->l = CWAIT(32, par->diwstrt_v-4);
3634 }
3635
3636 /*
3637 * Build the Copper List
3638 */
3639
3640 static void ami_build_copper(void)
3641 {
3642 struct amifb_par *par = &currentpar;
3643 copins *copl, *cops;
3644 u_long p;
3645
3646 currentcop = 1 - currentcop;
3647
3648 copl = copdisplay.list[currentcop][1];
3649
3650 (copl++)->l = CWAIT(0, 10);
3651 (copl++)->l = CMOVE(par->bplcon0, bplcon0);
3652 (copl++)->l = CMOVE(0, sprpt[0]);
3653 (copl++)->l = CMOVE2(0, sprpt[0]);
3654
3655 if (par->bplcon0 & BPC0_LACE) {
3656 cops = copdisplay.list[currentcop][0];
3657
3658 (cops++)->l = CWAIT(0, 10);
3659 (cops++)->l = CMOVE(par->bplcon0, bplcon0);
3660 (cops++)->l = CMOVE(0, sprpt[0]);
3661 (cops++)->l = CMOVE2(0, sprpt[0]);
3662
3663 (copl++)->l = CMOVE(diwstrt2hw(par->diwstrt_h, par->diwstrt_v+1), diwstrt);
3664 (copl++)->l = CMOVE(diwstop2hw(par->diwstop_h, par->diwstop_v+1), diwstop);
3665 (cops++)->l = CMOVE(diwstrt2hw(par->diwstrt_h, par->diwstrt_v), diwstrt);
3666 (cops++)->l = CMOVE(diwstop2hw(par->diwstop_h, par->diwstop_v), diwstop);
3667 if (!IS_OCS) {
3668 (copl++)->l = CMOVE(diwhigh2hw(par->diwstrt_h, par->diwstrt_v+1,
3669 par->diwstop_h, par->diwstop_v+1), diwhigh);
3670 (cops++)->l = CMOVE(diwhigh2hw(par->diwstrt_h, par->diwstrt_v,
3671 par->diwstop_h, par->diwstop_v), diwhigh);
3672 #if 0
3673 if (par->beamcon0 & BMC0_VARBEAMEN) {
3674 (copl++)->l = CMOVE(vtotal2hw(par->vtotal), vtotal);
3675 (copl++)->l = CMOVE(vbstrt2hw(par->vbstrt+1), vbstrt);
3676 (copl++)->l = CMOVE(vbstop2hw(par->vbstop+1), vbstop);
3677 (cops++)->l = CMOVE(vtotal2hw(par->vtotal), vtotal);
3678 (cops++)->l = CMOVE(vbstrt2hw(par->vbstrt), vbstrt);
3679 (cops++)->l = CMOVE(vbstop2hw(par->vbstop), vbstop);
3680 }
3681 #endif
3682 }
3683 p = ZTWO_PADDR(copdisplay.list[currentcop][0]);
3684 (copl++)->l = CMOVE(highw(p), cop2lc);
3685 (copl++)->l = CMOVE2(loww(p), cop2lc);
3686 p = ZTWO_PADDR(copdisplay.list[currentcop][1]);
3687 (cops++)->l = CMOVE(highw(p), cop2lc);
3688 (cops++)->l = CMOVE2(loww(p), cop2lc);
3689 copdisplay.rebuild[0] = cops;
3690 } else {
3691 (copl++)->l = CMOVE(diwstrt2hw(par->diwstrt_h, par->diwstrt_v), diwstrt);
3692 (copl++)->l = CMOVE(diwstop2hw(par->diwstop_h, par->diwstop_v), diwstop);
3693 if (!IS_OCS) {
3694 (copl++)->l = CMOVE(diwhigh2hw(par->diwstrt_h, par->diwstrt_v,
3695 par->diwstop_h, par->diwstop_v), diwhigh);
3696 #if 0
3697 if (par->beamcon0 & BMC0_VARBEAMEN) {
3698 (copl++)->l = CMOVE(vtotal2hw(par->vtotal), vtotal);
3699 (copl++)->l = CMOVE(vbstrt2hw(par->vbstrt), vbstrt);
3700 (copl++)->l = CMOVE(vbstop2hw(par->vbstop), vbstop);
3701 }
3702 #endif
3703 }
3704 }
3705 copdisplay.rebuild[1] = copl;
3706
3707 ami_update_par();
3708 ami_rebuild_copper();
3709 }
3710
3711 /*
3712 * Rebuild the Copper List
3713 *
3714 * We only change the things that are not static
3715 */
3716
3717 static void ami_rebuild_copper(void)
3718 {
3719 struct amifb_par *par = &currentpar;
3720 copins *copl, *cops;
3721 u_short line, h_end1, h_end2;
3722 short i;
3723 u_long p;
3724
3725 if (IS_AGA && maxfmode + par->clk_shift == 0)
3726 h_end1 = par->diwstrt_h-64;
3727 else
3728 h_end1 = par->htotal-32;
3729 h_end2 = par->ddfstop+64;
3730
3731 ami_set_sprite();
3732
3733 copl = copdisplay.rebuild[1];
3734 p = par->bplpt0;
3735 if (par->vmode & FB_VMODE_YWRAP) {
3736 if ((par->vyres-par->yoffset) != 1 || !mod2(par->diwstrt_v)) {
3737 if (par->yoffset > par->vyres-par->yres) {
3738 for (i = 0; i < (short)par->bpp; i++, p += par->next_plane) {
3739 (copl++)->l = CMOVE(highw(p), bplpt[i]);
3740 (copl++)->l = CMOVE2(loww(p), bplpt[i]);
3741 }
3742 line = par->diwstrt_v + ((par->vyres-par->yoffset)<<par->line_shift) - 1;
3743 while (line >= 512) {
3744 (copl++)->l = CWAIT(h_end1, 510);
3745 line -= 512;
3746 }
3747 if (line >= 510 && IS_AGA && maxfmode + par->clk_shift == 0)
3748 (copl++)->l = CWAIT(h_end1, line);
3749 else
3750 (copl++)->l = CWAIT(h_end2, line);
3751 p = par->bplpt0wrap;
3752 }
3753 } else p = par->bplpt0wrap;
3754 }
3755 for (i = 0; i < (short)par->bpp; i++, p += par->next_plane) {
3756 (copl++)->l = CMOVE(highw(p), bplpt[i]);
3757 (copl++)->l = CMOVE2(loww(p), bplpt[i]);
3758 }
3759 copl->l = CEND;
3760
3761 if (par->bplcon0 & BPC0_LACE) {
3762 cops = copdisplay.rebuild[0];
3763 p = par->bplpt0;
3764 if (mod2(par->diwstrt_v))
3765 p -= par->next_line;
3766 else
3767 p += par->next_line;
3768 if (par->vmode & FB_VMODE_YWRAP) {
3769 if ((par->vyres-par->yoffset) != 1 || mod2(par->diwstrt_v)) {
3770 if (par->yoffset > par->vyres-par->yres+1) {
3771 for (i = 0; i < (short)par->bpp; i++, p += par->next_plane) {
3772 (cops++)->l = CMOVE(highw(p), bplpt[i]);
3773 (cops++)->l = CMOVE2(loww(p), bplpt[i]);
3774 }
3775 line = par->diwstrt_v + ((par->vyres-par->yoffset)<<par->line_shift) - 2;
3776 while (line >= 512) {
3777 (cops++)->l = CWAIT(h_end1, 510);
3778 line -= 512;
3779 }
3780 if (line > 510 && IS_AGA && maxfmode + par->clk_shift == 0)
3781 (cops++)->l = CWAIT(h_end1, line);
3782 else
3783 (cops++)->l = CWAIT(h_end2, line);
3784 p = par->bplpt0wrap;
3785 if (mod2(par->diwstrt_v+par->vyres-par->yoffset))
3786 p -= par->next_line;
3787 else
3788 p += par->next_line;
3789 }
3790 } else p = par->bplpt0wrap - par->next_line;
3791 }
3792 for (i = 0; i < (short)par->bpp; i++, p += par->next_plane) {
3793 (cops++)->l = CMOVE(highw(p), bplpt[i]);
3794 (cops++)->l = CMOVE2(loww(p), bplpt[i]);
3795 }
3796 cops->l = CEND;
3797 }
3798 }
3799
3800
3801 module_init(amifb_init);
3802
3803 #ifdef MODULE
3804 MODULE_LICENSE("GPL");
3805
3806 void cleanup_module(void)
3807 {
3808 unregister_framebuffer(&fb_info);
3809 amifb_deinit();
3810 amifb_video_off();
3811 }
3812 #endif /* MODULE */
Verdex Pro support