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