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