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