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