fbdev/amifb: Reorder functions to remove forward declarations
authorGeert Uytterhoeven <geert@linux-m68k.org>
Mon, 21 Nov 2011 20:53:54 +0000 (21:53 +0100)
committerFlorian Tobias Schandinat <FlorianSchandinat@gmx.de>
Sat, 3 Dec 2011 22:03:32 +0000 (22:03 +0000)
No functional changes

Signed-off-by: Geert Uytterhoeven <geert@linux-m68k.org>
Signed-off-by: Florian Tobias Schandinat <FlorianSchandinat@gmx.de>
drivers/video/amifb.c

index 39d211ad164d35fd33a8a2f8b7812c0dd6f6dcbf..d7961bdc1124d560b53c6353e016028e7b10db76 100644 (file)
@@ -1118,2704 +1118,2649 @@ static u_short sprfetchmode[3] = {
 };
 
 
-       /*
-        * Interface used by the world
-        */
-
-int amifb_setup(char*);
-
-static int amifb_check_var(struct fb_var_screeninfo *var,
-                          struct fb_info *info);
-static int amifb_set_par(struct fb_info *info);
-static int amifb_setcolreg(unsigned regno, unsigned red, unsigned green,
-                          unsigned blue, unsigned transp,
-                          struct fb_info *info);
-static int amifb_blank(int blank, struct fb_info *info);
-static int amifb_pan_display(struct fb_var_screeninfo *var,
-                            struct fb_info *info);
-static void amifb_fillrect(struct fb_info *info,
-                          const struct fb_fillrect *rect);
-static void amifb_copyarea(struct fb_info *info,
-                          const struct fb_copyarea *region);
-static void amifb_imageblit(struct fb_info *info,
-                           const struct fb_image *image);
-static int amifb_ioctl(struct fb_info *info, unsigned int cmd, unsigned long arg);
-
-
-       /*
-        * Interface to the low level console driver
-        */
-
-static void amifb_deinit(struct platform_device *pdev);
-
-       /*
-        * Internal routines
-        */
-
-static int flash_cursor(void);
-static irqreturn_t amifb_interrupt(int irq, void *dev_id);
-static u_long chipalloc(u_long size);
-static void chipfree(void);
+/* --------------------------- Hardware routines --------------------------- */
 
        /*
-        * Hardware routines
+        * Get the video params out of `var'. If a value doesn't fit, round
+        * it up, if it's too big, return -EINVAL.
         */
 
 static int ami_decode_var(struct fb_var_screeninfo *var,
-                         struct amifb_par *par);
-static int ami_encode_var(struct fb_var_screeninfo *var,
-                         struct amifb_par *par);
-static void ami_pan_var(struct fb_var_screeninfo *var);
-static int ami_update_par(void);
-static void ami_update_display(void);
-static void ami_init_display(void);
-static void ami_do_blank(void);
-static int ami_get_fix_cursorinfo(struct fb_fix_cursorinfo *fix);
-static int ami_get_var_cursorinfo(struct fb_var_cursorinfo *var, u_char __user *data);
-static int ami_set_var_cursorinfo(struct fb_var_cursorinfo *var, u_char __user *data);
-static int ami_get_cursorstate(struct fb_cursorstate *state);
-static int ami_set_cursorstate(struct fb_cursorstate *state);
-static void ami_set_sprite(void);
-static void ami_init_copper(void);
-static void ami_reinit_copper(void);
-static void ami_build_copper(void);
-static void ami_rebuild_copper(void);
-
-
-static struct fb_ops amifb_ops = {
-       .owner          = THIS_MODULE,
-       .fb_check_var   = amifb_check_var,
-       .fb_set_par     = amifb_set_par,
-       .fb_setcolreg   = amifb_setcolreg,
-       .fb_blank       = amifb_blank,
-       .fb_pan_display = amifb_pan_display,
-       .fb_fillrect    = amifb_fillrect,
-       .fb_copyarea    = amifb_copyarea,
-       .fb_imageblit   = amifb_imageblit,
-       .fb_ioctl       = amifb_ioctl,
-};
-
-static void __init amifb_setup_mcap(char *spec)
+                         struct amifb_par *par)
 {
-       char *p;
-       int vmin, vmax, hmin, hmax;
+       u_short clk_shift, line_shift;
+       u_long maxfetchstop, fstrt, fsize, fconst, xres_n, yres_n;
+       u_int htotal, vtotal;
 
-       /* Format for monitor capabilities is: <Vmin>;<Vmax>;<Hmin>;<Hmax>
-        * <V*> vertical freq. in Hz
-        * <H*> horizontal freq. in kHz
+       /*
+        * Find a matching Pixel Clock
         */
 
-       if (!(p = strsep(&spec, ";")) || !*p)
-               return;
-       vmin = simple_strtoul(p, NULL, 10);
-       if (vmin <= 0)
-               return;
-       if (!(p = strsep(&spec, ";")) || !*p)
-               return;
-       vmax = simple_strtoul(p, NULL, 10);
-       if (vmax <= 0 || vmax <= vmin)
-               return;
-       if (!(p = strsep(&spec, ";")) || !*p)
-               return;
-       hmin = 1000 * simple_strtoul(p, NULL, 10);
-       if (hmin <= 0)
-               return;
-       if (!(p = strsep(&spec, "")) || !*p)
-               return;
-       hmax = 1000 * simple_strtoul(p, NULL, 10);
-       if (hmax <= 0 || hmax <= hmin)
-               return;
-
-       fb_info.monspecs.vfmin = vmin;
-       fb_info.monspecs.vfmax = vmax;
-       fb_info.monspecs.hfmin = hmin;
-       fb_info.monspecs.hfmax = hmax;
-}
-
-int __init amifb_setup(char *options)
-{
-       char *this_opt;
-
-       if (!options || !*options)
-               return 0;
-
-       while ((this_opt = strsep(&options, ",")) != NULL) {
-               if (!*this_opt)
-                       continue;
-               if (!strcmp(this_opt, "inverse")) {
-                       amifb_inverse = 1;
-                       fb_invert_cmaps();
-               } else if (!strcmp(this_opt, "ilbm"))
-                       amifb_ilbm = 1;
-               else if (!strncmp(this_opt, "monitorcap:", 11))
-                       amifb_setup_mcap(this_opt + 11);
-               else if (!strncmp(this_opt, "fstart:", 7))
-                       min_fstrt = simple_strtoul(this_opt + 7, NULL, 0);
-               else
-                       mode_option = this_opt;
+       for (clk_shift = TAG_SHRES; clk_shift <= TAG_LORES; clk_shift++)
+               if (var->pixclock <= pixclock[clk_shift])
+                       break;
+       if (clk_shift > TAG_LORES) {
+               DPRINTK("pixclock too high\n");
+               return -EINVAL;
        }
+       par->clk_shift = clk_shift;
 
-       if (min_fstrt < 48)
-               min_fstrt = 48;
-
-       return 0;
-}
-
-
-static int amifb_check_var(struct fb_var_screeninfo *var,
-                          struct fb_info *info)
-{
-       int err;
-       struct amifb_par par;
-
-       /* Validate wanted screen parameters */
-       if ((err = ami_decode_var(var, &par)))
-               return err;
-
-       /* Encode (possibly rounded) screen parameters */
-       ami_encode_var(var, &par);
-       return 0;
-}
-
-
-static int amifb_set_par(struct fb_info *info)
-{
-       struct amifb_par *par = (struct amifb_par *)info->par;
-
-       do_vmode_pan = 0;
-       do_vmode_full = 0;
-
-       /* Decode wanted screen parameters */
-       ami_decode_var(&info->var, par);
-
-       /* Set new videomode */
-       ami_build_copper();
-
-       /* Set VBlank trigger */
-       do_vmode_full = 1;
+       /*
+        * Check the Geometry Values
+        */
 
-       /* Update fix for new screen parameters */
-       if (par->bpp == 1) {
-               info->fix.type = FB_TYPE_PACKED_PIXELS;
-               info->fix.type_aux = 0;
-       } else if (amifb_ilbm) {
-               info->fix.type = FB_TYPE_INTERLEAVED_PLANES;
-               info->fix.type_aux = par->next_line;
-       } else {
-               info->fix.type = FB_TYPE_PLANES;
-               info->fix.type_aux = 0;
-       }
-       info->fix.line_length = div8(upx(16 << maxfmode, par->vxres));
+       if ((par->xres = var->xres) < 64)
+               par->xres = 64;
+       if ((par->yres = var->yres) < 64)
+               par->yres = 64;
+       if ((par->vxres = var->xres_virtual) < par->xres)
+               par->vxres = par->xres;
+       if ((par->vyres = var->yres_virtual) < par->yres)
+               par->vyres = par->yres;
 
-       if (par->vmode & FB_VMODE_YWRAP) {
-               info->fix.ywrapstep = 1;
-               info->fix.xpanstep = 0;
-               info->fix.ypanstep = 0;
-               info->flags = FBINFO_DEFAULT | FBINFO_HWACCEL_YWRAP |
-                       FBINFO_READS_FAST; /* override SCROLL_REDRAW */
+       par->bpp = var->bits_per_pixel;
+       if (!var->nonstd) {
+               if (par->bpp < 1)
+                       par->bpp = 1;
+               if (par->bpp > maxdepth[clk_shift]) {
+                       if (round_down_bpp && maxdepth[clk_shift])
+                               par->bpp = maxdepth[clk_shift];
+                       else {
+                               DPRINTK("invalid bpp\n");
+                               return -EINVAL;
+                       }
+               }
+       } else if (var->nonstd == FB_NONSTD_HAM) {
+               if (par->bpp < 6)
+                       par->bpp = 6;
+               if (par->bpp != 6) {
+                       if (par->bpp < 8)
+                               par->bpp = 8;
+                       if (par->bpp != 8 || !IS_AGA) {
+                               DPRINTK("invalid bpp for ham mode\n");
+                               return -EINVAL;
+                       }
+               }
        } else {
-               info->fix.ywrapstep = 0;
-               if (par->vmode & FB_VMODE_SMOOTH_XPAN)
-                       info->fix.xpanstep = 1;
-               else
-                       info->fix.xpanstep = 16 << maxfmode;
-               info->fix.ypanstep = 1;
-               info->flags = FBINFO_DEFAULT | FBINFO_HWACCEL_YPAN;
+               DPRINTK("unknown nonstd mode\n");
+               return -EINVAL;
        }
-       return 0;
-}
-
 
        /*
-        * Pan or Wrap the Display
-        *
-        * This call looks only at xoffset, yoffset and the FB_VMODE_YWRAP flag
+        * FB_VMODE_SMOOTH_XPAN will be cleared, if one of the folloing
+        * checks failed and smooth scrolling is not possible
         */
 
-static int amifb_pan_display(struct fb_var_screeninfo *var,
-                            struct fb_info *info)
-{
-       if (var->vmode & FB_VMODE_YWRAP) {
-               if (var->yoffset < 0 ||
-                       var->yoffset >= info->var.yres_virtual || var->xoffset)
-                               return -EINVAL;
-       } else {
-               /*
-                * TODO: There will be problems when xpan!=1, so some columns
-                * on the right side will never be seen
-                */
-               if (var->xoffset + info->var.xres >
-                   upx(16 << maxfmode, info->var.xres_virtual) ||
-                   var->yoffset + info->var.yres > info->var.yres_virtual)
+       par->vmode = var->vmode | FB_VMODE_SMOOTH_XPAN;
+       switch (par->vmode & FB_VMODE_MASK) {
+       case FB_VMODE_INTERLACED:
+               line_shift = 0;
+               break;
+       case FB_VMODE_NONINTERLACED:
+               line_shift = 1;
+               break;
+       case FB_VMODE_DOUBLE:
+               if (!IS_AGA) {
+                       DPRINTK("double mode only possible with aga\n");
                        return -EINVAL;
+               }
+               line_shift = 2;
+               break;
+       default:
+               DPRINTK("unknown video mode\n");
+               return -EINVAL;
+               break;
        }
-       ami_pan_var(var);
-       info->var.xoffset = var->xoffset;
-       info->var.yoffset = var->yoffset;
-       if (var->vmode & FB_VMODE_YWRAP)
-               info->var.vmode |= FB_VMODE_YWRAP;
-       else
-               info->var.vmode &= ~FB_VMODE_YWRAP;
-       return 0;
-}
+       par->line_shift = line_shift;
 
+       /*
+        * Vertical and Horizontal Timings
+        */
 
-#if BITS_PER_LONG == 32
-#define BYTES_PER_LONG 4
-#define SHIFT_PER_LONG 5
-#elif BITS_PER_LONG == 64
-#define BYTES_PER_LONG 8
-#define SHIFT_PER_LONG 6
-#else
-#define Please update me
-#endif
+       xres_n = par->xres << clk_shift;
+       yres_n = par->yres << line_shift;
+       par->htotal = down8((var->left_margin + par->xres + var->right_margin +
+                            var->hsync_len) << clk_shift);
+       par->vtotal =
+               down2(((var->upper_margin + par->yres + var->lower_margin +
+                       var->vsync_len) << line_shift) + 1);
+
+       if (IS_AGA)
+               par->bplcon3 = sprpixmode[clk_shift];
+       else
+               par->bplcon3 = 0;
+       if (var->sync & FB_SYNC_BROADCAST) {
+               par->diwstop_h = par->htotal -
+                       ((var->right_margin - var->hsync_len) << clk_shift);
+               if (IS_AGA)
+                       par->diwstop_h += mod4(var->hsync_len);
+               else
+                       par->diwstop_h = down4(par->diwstop_h);
+
+               par->diwstrt_h = par->diwstop_h - xres_n;
+               par->diwstop_v = par->vtotal -
+                       ((var->lower_margin - var->vsync_len) << line_shift);
+               par->diwstrt_v = par->diwstop_v - yres_n;
+               if (par->diwstop_h >= par->htotal + 8) {
+                       DPRINTK("invalid diwstop_h\n");
+                       return -EINVAL;
+               }
+               if (par->diwstop_v > par->vtotal) {
+                       DPRINTK("invalid diwstop_v\n");
+                       return -EINVAL;
+               }
 
+               if (!IS_OCS) {
+                       /* Initialize sync with some reasonable values for pwrsave */
+                       par->hsstrt = 160;
+                       par->hsstop = 320;
+                       par->vsstrt = 30;
+                       par->vsstop = 34;
+               } else {
+                       par->hsstrt = 0;
+                       par->hsstop = 0;
+                       par->vsstrt = 0;
+                       par->vsstop = 0;
+               }
+               if (par->vtotal > (PAL_VTOTAL + NTSC_VTOTAL) / 2) {
+                       /* PAL video mode */
+                       if (par->htotal != PAL_HTOTAL) {
+                               DPRINTK("htotal invalid for pal\n");
+                               return -EINVAL;
+                       }
+                       if (par->diwstrt_h < PAL_DIWSTRT_H) {
+                               DPRINTK("diwstrt_h too low for pal\n");
+                               return -EINVAL;
+                       }
+                       if (par->diwstrt_v < PAL_DIWSTRT_V) {
+                               DPRINTK("diwstrt_v too low for pal\n");
+                               return -EINVAL;
+                       }
+                       htotal = PAL_HTOTAL>>clk_shift;
+                       vtotal = PAL_VTOTAL>>1;
+                       if (!IS_OCS) {
+                               par->beamcon0 = BMC0_PAL;
+                               par->bplcon3 |= BPC3_BRDRBLNK;
+                       } else if (AMIGAHW_PRESENT(AGNUS_HR_PAL) ||
+                                  AMIGAHW_PRESENT(AGNUS_HR_NTSC)) {
+                               par->beamcon0 = BMC0_PAL;
+                               par->hsstop = 1;
+                       } else if (amiga_vblank != 50) {
+                               DPRINTK("pal not supported by this chipset\n");
+                               return -EINVAL;
+                       }
+               } else {
+                       /* NTSC video mode
+                        * In the AGA chipset seems to be hardware bug with BPC3_BRDRBLNK
+                        * and NTSC activated, so than better let diwstop_h <= 1812
+                        */
+                       if (par->htotal != NTSC_HTOTAL) {
+                               DPRINTK("htotal invalid for ntsc\n");
+                               return -EINVAL;
+                       }
+                       if (par->diwstrt_h < NTSC_DIWSTRT_H) {
+                               DPRINTK("diwstrt_h too low for ntsc\n");
+                               return -EINVAL;
+                       }
+                       if (par->diwstrt_v < NTSC_DIWSTRT_V) {
+                               DPRINTK("diwstrt_v too low for ntsc\n");
+                               return -EINVAL;
+                       }
+                       htotal = NTSC_HTOTAL>>clk_shift;
+                       vtotal = NTSC_VTOTAL>>1;
+                       if (!IS_OCS) {
+                               par->beamcon0 = 0;
+                               par->bplcon3 |= BPC3_BRDRBLNK;
+                       } else if (AMIGAHW_PRESENT(AGNUS_HR_PAL) ||
+                                  AMIGAHW_PRESENT(AGNUS_HR_NTSC)) {
+                               par->beamcon0 = 0;
+                               par->hsstop = 1;
+                       } else if (amiga_vblank != 60) {
+                               DPRINTK("ntsc not supported by this chipset\n");
+                               return -EINVAL;
+                       }
+               }
+               if (IS_OCS) {
+                       if (par->diwstrt_h >= 1024 || par->diwstop_h < 1024 ||
+                           par->diwstrt_v >=  512 || par->diwstop_v <  256) {
+                               DPRINTK("invalid position for display on ocs\n");
+                               return -EINVAL;
+                       }
+               }
+       } else if (!IS_OCS) {
+               /* Programmable video mode */
+               par->hsstrt = var->right_margin << clk_shift;
+               par->hsstop = (var->right_margin + var->hsync_len) << clk_shift;
+               par->diwstop_h = par->htotal - mod8(par->hsstrt) + 8 - (1 << clk_shift);
+               if (!IS_AGA)
+                       par->diwstop_h = down4(par->diwstop_h) - 16;
+               par->diwstrt_h = par->diwstop_h - xres_n;
+               par->hbstop = par->diwstrt_h + 4;
+               par->hbstrt = par->diwstop_h + 4;
+               if (par->hbstrt >= par->htotal + 8)
+                       par->hbstrt -= par->htotal;
+               par->hcenter = par->hsstrt + (par->htotal >> 1);
+               par->vsstrt = var->lower_margin << line_shift;
+               par->vsstop = (var->lower_margin + var->vsync_len) << line_shift;
+               par->diwstop_v = par->vtotal;
+               if ((par->vmode & FB_VMODE_MASK) == FB_VMODE_INTERLACED)
+                       par->diwstop_v -= 2;
+               par->diwstrt_v = par->diwstop_v - yres_n;
+               par->vbstop = par->diwstrt_v - 2;
+               par->vbstrt = par->diwstop_v - 2;
+               if (par->vtotal > 2048) {
+                       DPRINTK("vtotal too high\n");
+                       return -EINVAL;
+               }
+               if (par->htotal > 2048) {
+                       DPRINTK("htotal too high\n");
+                       return -EINVAL;
+               }
+               par->bplcon3 |= BPC3_EXTBLKEN;
+               par->beamcon0 = BMC0_HARDDIS | BMC0_VARVBEN | BMC0_LOLDIS |
+                               BMC0_VARVSYEN | BMC0_VARHSYEN | BMC0_VARBEAMEN |
+                               BMC0_PAL | BMC0_VARCSYEN;
+               if (var->sync & FB_SYNC_HOR_HIGH_ACT)
+                       par->beamcon0 |= BMC0_HSYTRUE;
+               if (var->sync & FB_SYNC_VERT_HIGH_ACT)
+                       par->beamcon0 |= BMC0_VSYTRUE;
+               if (var->sync & FB_SYNC_COMP_HIGH_ACT)
+                       par->beamcon0 |= BMC0_CSYTRUE;
+               htotal = par->htotal>>clk_shift;
+               vtotal = par->vtotal>>1;
+       } else {
+               DPRINTK("only broadcast modes possible for ocs\n");
+               return -EINVAL;
+       }
 
        /*
-        *  Compose two values, using a bitmask as decision value
-        *  This is equivalent to (a & mask) | (b & ~mask)
+        * Checking the DMA timing
         */
 
-static inline unsigned long comp(unsigned long a, unsigned long b,
-                                unsigned long mask)
-{
-       return ((a ^ b) & mask) ^ b;
-}
+       fconst = 16 << maxfmode << clk_shift;
 
+       /*
+        * smallest window start value without turn off other dma cycles
+        * than sprite1-7, unless you change min_fstrt
+        */
 
-static inline unsigned long xor(unsigned long a, unsigned long b,
-                               unsigned long mask)
-{
-       return (a & mask) ^ b;
-}
 
+       fsize = ((maxfmode + clk_shift <= 1) ? fconst : 64);
+       fstrt = downx(fconst, par->diwstrt_h - 4) - fsize;
+       if (fstrt < min_fstrt) {
+               DPRINTK("fetch start too low\n");
+               return -EINVAL;
+       }
 
        /*
-        *  Unaligned forward bit copy using 32-bit or 64-bit memory accesses
+        * smallest window start value where smooth scrolling is possible
         */
 
-static void bitcpy(unsigned long *dst, int dst_idx, const unsigned long *src,
-                  int src_idx, u32 n)
-{
-       unsigned long first, last;
-       int shift = dst_idx - src_idx, left, right;
-       unsigned long d0, d1;
-       int m;
+       fstrt = downx(fconst, par->diwstrt_h - fconst + (1 << clk_shift) - 4) -
+               fsize;
+       if (fstrt < min_fstrt)
+               par->vmode &= ~FB_VMODE_SMOOTH_XPAN;
 
-       if (!n)
-               return;
+       maxfetchstop = down16(par->htotal - 80);
 
-       shift = dst_idx - src_idx;
-       first = ~0UL >> dst_idx;
-       last = ~(~0UL >> ((dst_idx + n) % BITS_PER_LONG));
+       fstrt = downx(fconst, par->diwstrt_h - 4) - 64 - fconst;
+       fsize = upx(fconst, xres_n +
+                   modx(fconst, downx(1 << clk_shift, par->diwstrt_h - 4)));
+       if (fstrt + fsize > maxfetchstop)
+               par->vmode &= ~FB_VMODE_SMOOTH_XPAN;
 
-       if (!shift) {
-               // Same alignment for source and dest
+       fsize = upx(fconst, xres_n);
+       if (fstrt + fsize > maxfetchstop) {
+               DPRINTK("fetch stop too high\n");
+               return -EINVAL;
+       }
 
-               if (dst_idx + n <= BITS_PER_LONG) {
-                       // Single word
-                       if (last)
-                               first &= last;
-                       *dst = comp(*src, *dst, first);
-               } else {
-                       // Multiple destination words
-                       // Leading bits
-                       if (first) {
-                               *dst = comp(*src, *dst, first);
-                               dst++;
-                               src++;
-                               n -= BITS_PER_LONG - dst_idx;
-                       }
+       if (maxfmode + clk_shift <= 1) {
+               fsize = up64(xres_n + fconst - 1);
+               if (min_fstrt + fsize - 64 > maxfetchstop)
+                       par->vmode &= ~FB_VMODE_SMOOTH_XPAN;
 
-                       // Main chunk
-                       n /= BITS_PER_LONG;
-                       while (n >= 8) {
-                               *dst++ = *src++;
-                               *dst++ = *src++;
-                               *dst++ = *src++;
-                               *dst++ = *src++;
-                               *dst++ = *src++;
-                               *dst++ = *src++;
-                               *dst++ = *src++;
-                               *dst++ = *src++;
-                               n -= 8;
-                       }
-                       while (n--)
-                               *dst++ = *src++;
+               fsize = up64(xres_n);
+               if (min_fstrt + fsize - 64 > maxfetchstop) {
+                       DPRINTK("fetch size too high\n");
+                       return -EINVAL;
+               }
 
-                       // Trailing bits
-                       if (last)
-                               *dst = comp(*src, *dst, last);
+               fsize -= 64;
+       } else
+               fsize -= fconst;
+
+       /*
+        * Check if there is enough time to update the bitplane pointers for ywrap
+        */
+
+       if (par->htotal - fsize - 64 < par->bpp * 64)
+               par->vmode &= ~FB_VMODE_YWRAP;
+
+       /*
+        * Bitplane calculations and check the Memory Requirements
+        */
+
+       if (amifb_ilbm) {
+               par->next_plane = div8(upx(16 << maxfmode, par->vxres));
+               par->next_line = par->bpp * par->next_plane;
+               if (par->next_line * par->vyres > fb_info.fix.smem_len) {
+                       DPRINTK("too few video mem\n");
+                       return -EINVAL;
                }
        } else {
-               // Different alignment for source and dest
+               par->next_line = div8(upx(16 << maxfmode, par->vxres));
+               par->next_plane = par->vyres * par->next_line;
+               if (par->next_plane * par->bpp > fb_info.fix.smem_len) {
+                       DPRINTK("too few video mem\n");
+                       return -EINVAL;
+               }
+       }
 
-               right = shift & (BITS_PER_LONG - 1);
-               left = -shift & (BITS_PER_LONG - 1);
+       /*
+        * Hardware Register Values
+        */
 
-               if (dst_idx + n <= BITS_PER_LONG) {
-                       // Single destination word
-                       if (last)
-                               first &= last;
-                       if (shift > 0) {
-                               // Single source word
-                               *dst = comp(*src >> right, *dst, first);
-                       } else if (src_idx + n <= BITS_PER_LONG) {
-                               // Single source word
-                               *dst = comp(*src << left, *dst, first);
-                       } else {
-                               // 2 source words
-                               d0 = *src++;
-                               d1 = *src;
-                               *dst = comp(d0 << left | d1 >> right, *dst,
-                                           first);
-                       }
-               } else {
-                       // Multiple destination words
-                       d0 = *src++;
-                       // Leading bits
-                       if (shift > 0) {
-                               // Single source word
-                               *dst = comp(d0 >> right, *dst, first);
-                               dst++;
-                               n -= BITS_PER_LONG - dst_idx;
-                       } else {
-                               // 2 source words
-                               d1 = *src++;
-                               *dst = comp(d0 << left | d1 >> right, *dst,
-                                           first);
-                               d0 = d1;
-                               dst++;
-                               n -= BITS_PER_LONG - dst_idx;
-                       }
+       par->bplcon0 = BPC0_COLOR | bplpixmode[clk_shift];
+       if (!IS_OCS)
+               par->bplcon0 |= BPC0_ECSENA;
+       if (par->bpp == 8)
+               par->bplcon0 |= BPC0_BPU3;
+       else
+               par->bplcon0 |= par->bpp << 12;
+       if (var->nonstd == FB_NONSTD_HAM)
+               par->bplcon0 |= BPC0_HAM;
+       if (var->sync & FB_SYNC_EXT)
+               par->bplcon0 |= BPC0_ERSY;
 
-                       // Main chunk
-                       m = n % BITS_PER_LONG;
-                       n /= BITS_PER_LONG;
-                       while (n >= 4) {
-                               d1 = *src++;
-                               *dst++ = d0 << left | d1 >> right;
-                               d0 = d1;
-                               d1 = *src++;
-                               *dst++ = d0 << left | d1 >> right;
-                               d0 = d1;
-                               d1 = *src++;
-                               *dst++ = d0 << left | d1 >> right;
-                               d0 = d1;
-                               d1 = *src++;
-                               *dst++ = d0 << left | d1 >> right;
-                               d0 = d1;
-                               n -= 4;
-                       }
-                       while (n--) {
-                               d1 = *src++;
-                               *dst++ = d0 << left | d1 >> right;
-                               d0 = d1;
-                       }
+       if (IS_AGA)
+               par->fmode = bplfetchmode[maxfmode];
 
-                       // Trailing bits
-                       if (last) {
-                               if (m <= right) {
-                                       // Single source word
-                                       *dst = comp(d0 << left, *dst, last);
-                               } else {
-                                       // 2 source words
-                                       d1 = *src;
-                                       *dst = comp(d0 << left | d1 >> right,
-                                                   *dst, last);
-                               }
-                       }
-               }
+       switch (par->vmode & FB_VMODE_MASK) {
+       case FB_VMODE_INTERLACED:
+               par->bplcon0 |= BPC0_LACE;
+               break;
+       case FB_VMODE_DOUBLE:
+               if (IS_AGA)
+                       par->fmode |= FMODE_SSCAN2 | FMODE_BSCAN2;
+               break;
        }
-}
 
+       if (!((par->vmode ^ var->vmode) & FB_VMODE_YWRAP)) {
+               par->xoffset = var->xoffset;
+               par->yoffset = var->yoffset;
+               if (par->vmode & FB_VMODE_YWRAP) {
+                       if (par->xoffset || par->yoffset < 0 ||
+                           par->yoffset >= par->vyres)
+                               par->xoffset = par->yoffset = 0;
+               } else {
+                       if (par->xoffset < 0 ||
+                           par->xoffset > upx(16 << maxfmode, par->vxres - par->xres) ||
+                           par->yoffset < 0 || par->yoffset > par->vyres - par->yres)
+                               par->xoffset = par->yoffset = 0;
+               }
+       } else
+               par->xoffset = par->yoffset = 0;
+
+       par->crsr.crsr_x = par->crsr.crsr_y = 0;
+       par->crsr.spot_x = par->crsr.spot_y = 0;
+       par->crsr.height = par->crsr.width = 0;
+
+       return 0;
+}
 
        /*
-        *  Unaligned reverse bit copy using 32-bit or 64-bit memory accesses
+        * Fill the `var' structure based on the values in `par' and maybe
+        * other values read out of the hardware.
         */
 
-static void bitcpy_rev(unsigned long *dst, int dst_idx,
-                      const unsigned long *src, int src_idx, u32 n)
+static int ami_encode_var(struct fb_var_screeninfo *var,
+                         struct amifb_par *par)
 {
-       unsigned long first, last;
-       int shift = dst_idx - src_idx, left, right;
-       unsigned long d0, d1;
-       int m;
+       u_short clk_shift, line_shift;
 
-       if (!n)
-               return;
+       memset(var, 0, sizeof(struct fb_var_screeninfo));
 
-       dst += (n - 1) / BITS_PER_LONG;
-       src += (n - 1) / BITS_PER_LONG;
-       if ((n - 1) % BITS_PER_LONG) {
-               dst_idx += (n - 1) % BITS_PER_LONG;
-               dst += dst_idx >> SHIFT_PER_LONG;
-               dst_idx &= BITS_PER_LONG - 1;
-               src_idx += (n - 1) % BITS_PER_LONG;
-               src += src_idx >> SHIFT_PER_LONG;
-               src_idx &= BITS_PER_LONG - 1;
-       }
+       clk_shift = par->clk_shift;
+       line_shift = par->line_shift;
 
-       shift = dst_idx - src_idx;
-       first = ~0UL << (BITS_PER_LONG - 1 - dst_idx);
-       last = ~(~0UL << (BITS_PER_LONG - 1 - ((dst_idx - n) % BITS_PER_LONG)));
+       var->xres = par->xres;
+       var->yres = par->yres;
+       var->xres_virtual = par->vxres;
+       var->yres_virtual = par->vyres;
+       var->xoffset = par->xoffset;
+       var->yoffset = par->yoffset;
 
-       if (!shift) {
-               // Same alignment for source and dest
+       var->bits_per_pixel = par->bpp;
+       var->grayscale = 0;
 
-               if ((unsigned long)dst_idx + 1 >= n) {
-                       // Single word
-                       if (last)
-                               first &= last;
-                       *dst = comp(*src, *dst, first);
-               } else {
-                       // Multiple destination words
-                       // Leading bits
-                       if (first) {
-                               *dst = comp(*src, *dst, first);
-                               dst--;
-                               src--;
-                               n -= dst_idx + 1;
-                       }
+       var->red.offset = 0;
+       var->red.msb_right = 0;
+       var->red.length = par->bpp;
+       if (par->bplcon0 & BPC0_HAM)
+               var->red.length -= 2;
+       var->blue = var->green = var->red;
+       var->transp.offset = 0;
+       var->transp.length = 0;
+       var->transp.msb_right = 0;
 
-                       // Main chunk
-                       n /= BITS_PER_LONG;
-                       while (n >= 8) {
-                               *dst-- = *src--;
-                               *dst-- = *src--;
-                               *dst-- = *src--;
-                               *dst-- = *src--;
-                               *dst-- = *src--;
-                               *dst-- = *src--;
-                               *dst-- = *src--;
-                               *dst-- = *src--;
-                               n -= 8;
-                       }
-                       while (n--)
-                               *dst-- = *src--;
+       if (par->bplcon0 & BPC0_HAM)
+               var->nonstd = FB_NONSTD_HAM;
+       else
+               var->nonstd = 0;
+       var->activate = 0;
 
-                       // Trailing bits
-                       if (last)
-                               *dst = comp(*src, *dst, last);
-               }
-       } else {
-               // Different alignment for source and dest
+       var->height = -1;
+       var->width = -1;
 
-               right = shift & (BITS_PER_LONG - 1);
-               left = -shift & (BITS_PER_LONG - 1);
+       var->pixclock = pixclock[clk_shift];
 
-               if ((unsigned long)dst_idx + 1 >= n) {
-                       // Single destination word
-                       if (last)
-                               first &= last;
-                       if (shift < 0) {
-                               // Single source word
-                               *dst = comp(*src << left, *dst, first);
-                       } else if (1 + (unsigned long)src_idx >= n) {
-                               // Single source word
-                               *dst = comp(*src >> right, *dst, first);
-                       } else {
-                               // 2 source words
-                               d0 = *src--;
-                               d1 = *src;
-                               *dst = comp(d0 >> right | d1 << left, *dst,
-                                           first);
-                       }
-               } else {
-                       // Multiple destination words
-                       d0 = *src--;
-                       // Leading bits
-                       if (shift < 0) {
-                               // Single source word
-                               *dst = comp(d0 << left, *dst, first);
-                               dst--;
-                               n -= dst_idx + 1;
-                       } else {
-                               // 2 source words
-                               d1 = *src--;
-                               *dst = comp(d0 >> right | d1 << left, *dst,
-                                           first);
-                               d0 = d1;
-                               dst--;
-                               n -= dst_idx + 1;
-                       }
-
-                       // Main chunk
-                       m = n % BITS_PER_LONG;
-                       n /= BITS_PER_LONG;
-                       while (n >= 4) {
-                               d1 = *src--;
-                               *dst-- = d0 >> right | d1 << left;
-                               d0 = d1;
-                               d1 = *src--;
-                               *dst-- = d0 >> right | d1 << left;
-                               d0 = d1;
-                               d1 = *src--;
-                               *dst-- = d0 >> right | d1 << left;
-                               d0 = d1;
-                               d1 = *src--;
-                               *dst-- = d0 >> right | d1 << left;
-                               d0 = d1;
-                               n -= 4;
-                       }
-                       while (n--) {
-                               d1 = *src--;
-                               *dst-- = d0 >> right | d1 << left;
-                               d0 = d1;
-                       }
+       if (IS_AGA && par->fmode & FMODE_BSCAN2)
+               var->vmode = FB_VMODE_DOUBLE;
+       else if (par->bplcon0 & BPC0_LACE)
+               var->vmode = FB_VMODE_INTERLACED;
+       else
+               var->vmode = FB_VMODE_NONINTERLACED;
 
-                       // Trailing bits
-                       if (last) {
-                               if (m <= left) {
-                                       // Single source word
-                                       *dst = comp(d0 >> right, *dst, last);
-                               } else {
-                                       // 2 source words
-                                       d1 = *src;
-                                       *dst = comp(d0 >> right | d1 << left,
-                                                   *dst, last);
-                               }
-                       }
-               }
+       if (!IS_OCS && par->beamcon0 & BMC0_VARBEAMEN) {
+               var->hsync_len = (par->hsstop - par->hsstrt)>>clk_shift;
+               var->right_margin = par->hsstrt>>clk_shift;
+               var->left_margin = (par->htotal>>clk_shift) - var->xres - var->right_margin - var->hsync_len;
+               var->vsync_len = (par->vsstop - par->vsstrt)>>line_shift;
+               var->lower_margin = par->vsstrt>>line_shift;
+               var->upper_margin = (par->vtotal>>line_shift) - var->yres - var->lower_margin - var->vsync_len;
+               var->sync = 0;
+               if (par->beamcon0 & BMC0_HSYTRUE)
+                       var->sync |= FB_SYNC_HOR_HIGH_ACT;
+               if (par->beamcon0 & BMC0_VSYTRUE)
+                       var->sync |= FB_SYNC_VERT_HIGH_ACT;
+               if (par->beamcon0 & BMC0_CSYTRUE)
+                       var->sync |= FB_SYNC_COMP_HIGH_ACT;
+       } else {
+               var->sync = FB_SYNC_BROADCAST;
+               var->hsync_len = (152>>clk_shift) + mod4(par->diwstop_h);
+               var->right_margin = ((par->htotal - down4(par->diwstop_h))>>clk_shift) + var->hsync_len;
+               var->left_margin = (par->htotal>>clk_shift) - var->xres - var->right_margin - var->hsync_len;
+               var->vsync_len = 4>>line_shift;
+               var->lower_margin = ((par->vtotal - par->diwstop_v)>>line_shift) + var->vsync_len;
+               var->upper_margin = (((par->vtotal - 2)>>line_shift) + 1) - var->yres -
+                                   var->lower_margin - var->vsync_len;
        }
+
+       if (par->bplcon0 & BPC0_ERSY)
+               var->sync |= FB_SYNC_EXT;
+       if (par->vmode & FB_VMODE_YWRAP)
+               var->vmode |= FB_VMODE_YWRAP;
+
+       return 0;
 }
 
 
        /*
-        *  Unaligned forward inverting bit copy using 32-bit or 64-bit memory
-        *  accesses
+        * Update hardware
         */
 
-static void bitcpy_not(unsigned long *dst, int dst_idx,
-                      const unsigned long *src, int src_idx, u32 n)
+static int ami_update_par(void)
 {
-       unsigned long first, last;
-       int shift = dst_idx - src_idx, left, right;
-       unsigned long d0, d1;
-       int m;
+       struct amifb_par *par = &currentpar;
+       short clk_shift, vshift, fstrt, fsize, fstop, fconst,  shift, move, mod;
 
-       if (!n)
-               return;
+       clk_shift = par->clk_shift;
 
-       shift = dst_idx - src_idx;
-       first = ~0UL >> dst_idx;
-       last = ~(~0UL >> ((dst_idx + n) % BITS_PER_LONG));
+       if (!(par->vmode & FB_VMODE_SMOOTH_XPAN))
+               par->xoffset = upx(16 << maxfmode, par->xoffset);
 
-       if (!shift) {
-               // Same alignment for source and dest
+       fconst = 16 << maxfmode << clk_shift;
+       vshift = modx(16 << maxfmode, par->xoffset);
+       fstrt = par->diwstrt_h - (vshift << clk_shift) - 4;
+       fsize = (par->xres + vshift) << clk_shift;
+       shift = modx(fconst, fstrt);
+       move = downx(2 << maxfmode, div8(par->xoffset));
+       if (maxfmode + clk_shift > 1) {
+               fstrt = downx(fconst, fstrt) - 64;
+               fsize = upx(fconst, fsize);
+               fstop = fstrt + fsize - fconst;
+       } else {
+               mod = fstrt = downx(fconst, fstrt) - fconst;
+               fstop = fstrt + upx(fconst, fsize) - 64;
+               fsize = up64(fsize);
+               fstrt = fstop - fsize + 64;
+               if (fstrt < min_fstrt) {
+                       fstop += min_fstrt - fstrt;
+                       fstrt = min_fstrt;
+               }
+               move = move - div8((mod - fstrt)>>clk_shift);
+       }
+       mod = par->next_line - div8(fsize>>clk_shift);
+       par->ddfstrt = fstrt;
+       par->ddfstop = fstop;
+       par->bplcon1 = hscroll2hw(shift);
+       par->bpl2mod = mod;
+       if (par->bplcon0 & BPC0_LACE)
+               par->bpl2mod += par->next_line;
+       if (IS_AGA && (par->fmode & FMODE_BSCAN2))
+               par->bpl1mod = -div8(fsize>>clk_shift);
+       else
+               par->bpl1mod = par->bpl2mod;
 
-               if (dst_idx + n <= BITS_PER_LONG) {
-                       // Single word
-                       if (last)
-                               first &= last;
-                       *dst = comp(~*src, *dst, first);
-               } else {
-                       // Multiple destination words
-                       // Leading bits
-                       if (first) {
-                               *dst = comp(~*src, *dst, first);
-                               dst++;
-                               src++;
-                               n -= BITS_PER_LONG - dst_idx;
+       if (par->yoffset) {
+               par->bplpt0 = fb_info.fix.smem_start +
+                             par->next_line * par->yoffset + move;
+               if (par->vmode & FB_VMODE_YWRAP) {
+                       if (par->yoffset > par->vyres - par->yres) {
+                               par->bplpt0wrap = fb_info.fix.smem_start + move;
+                               if (par->bplcon0 & BPC0_LACE &&
+                                   mod2(par->diwstrt_v + par->vyres -
+                                        par->yoffset))
+                                       par->bplpt0wrap += par->next_line;
                        }
+               }
+       } else
+               par->bplpt0 = fb_info.fix.smem_start + move;
 
-                       // Main chunk
-                       n /= BITS_PER_LONG;
-                       while (n >= 8) {
-                               *dst++ = ~*src++;
-                               *dst++ = ~*src++;
-                               *dst++ = ~*src++;
-                               *dst++ = ~*src++;
-                               *dst++ = ~*src++;
-                               *dst++ = ~*src++;
-                               *dst++ = ~*src++;
-                               *dst++ = ~*src++;
-                               n -= 8;
-                       }
-                       while (n--)
-                               *dst++ = ~*src++;
+       if (par->bplcon0 & BPC0_LACE && mod2(par->diwstrt_v))
+               par->bplpt0 += par->next_line;
 
-                       // Trailing bits
-                       if (last)
-                               *dst = comp(~*src, *dst, last);
-               }
-       } else {
-               // Different alignment for source and dest
+       return 0;
+}
 
-               right = shift & (BITS_PER_LONG - 1);
-               left = -shift & (BITS_PER_LONG - 1);
 
-               if (dst_idx + n <= BITS_PER_LONG) {
-                       // Single destination word
-                       if (last)
-                               first &= last;
-                       if (shift > 0) {
-                               // Single source word
-                               *dst = comp(~*src >> right, *dst, first);
-                       } else if (src_idx + n <= BITS_PER_LONG) {
-                               // Single source word
-                               *dst = comp(~*src << left, *dst, first);
-                       } else {
-                               // 2 source words
-                               d0 = ~*src++;
-                               d1 = ~*src;
-                               *dst = comp(d0 << left | d1 >> right, *dst,
-                                           first);
-                       }
-               } else {
-                       // Multiple destination words
-                       d0 = ~*src++;
-                       // Leading bits
-                       if (shift > 0) {
-                               // Single source word
-                               *dst = comp(d0 >> right, *dst, first);
-                               dst++;
-                               n -= BITS_PER_LONG - dst_idx;
-                       } else {
-                               // 2 source words
-                               d1 = ~*src++;
-                               *dst = comp(d0 << left | d1 >> right, *dst,
-                                           first);
-                               d0 = d1;
-                               dst++;
-                               n -= BITS_PER_LONG - dst_idx;
-                       }
+       /*
+        * Pan or Wrap the Display
+        *
+        * This call looks only at xoffset, yoffset and the FB_VMODE_YWRAP flag
+        * in `var'.
+        */
 
-                       // Main chunk
-                       m = n % BITS_PER_LONG;
-                       n /= BITS_PER_LONG;
-                       while (n >= 4) {
-                               d1 = ~*src++;
-                               *dst++ = d0 << left | d1 >> right;
-                               d0 = d1;
-                               d1 = ~*src++;
-                               *dst++ = d0 << left | d1 >> right;
-                               d0 = d1;
-                               d1 = ~*src++;
-                               *dst++ = d0 << left | d1 >> right;
-                               d0 = d1;
-                               d1 = ~*src++;
-                               *dst++ = d0 << left | d1 >> right;
-                               d0 = d1;
-                               n -= 4;
-                       }
-                       while (n--) {
-                               d1 = ~*src++;
-                               *dst++ = d0 << left | d1 >> right;
-                               d0 = d1;
-                       }
+static void ami_pan_var(struct fb_var_screeninfo *var)
+{
+       struct amifb_par *par = &currentpar;
 
-                       // Trailing bits
-                       if (last) {
-                               if (m <= right) {
-                                       // Single source word
-                                       *dst = comp(d0 << left, *dst, last);
-                               } else {
-                                       // 2 source words
-                                       d1 = ~*src;
-                                       *dst = comp(d0 << left | d1 >> right,
-                                                   *dst, last);
-                               }
-                       }
-               }
-       }
+       par->xoffset = var->xoffset;
+       par->yoffset = var->yoffset;
+       if (var->vmode & FB_VMODE_YWRAP)
+               par->vmode |= FB_VMODE_YWRAP;
+       else
+               par->vmode &= ~FB_VMODE_YWRAP;
+
+       do_vmode_pan = 0;
+       ami_update_par();
+       do_vmode_pan = 1;
 }
 
 
+static void ami_update_display(void)
+{
+       struct amifb_par *par = &currentpar;
+
+       custom.bplcon1 = par->bplcon1;
+       custom.bpl1mod = par->bpl1mod;
+       custom.bpl2mod = par->bpl2mod;
+       custom.ddfstrt = ddfstrt2hw(par->ddfstrt);
+       custom.ddfstop = ddfstop2hw(par->ddfstop);
+}
+
        /*
-        *  Unaligned 32-bit pattern fill using 32/64-bit memory accesses
+        * Change the video mode (called by VBlank interrupt)
         */
 
-static void bitfill32(unsigned long *dst, int dst_idx, u32 pat, u32 n)
+static void ami_init_display(void)
 {
-       unsigned long val = pat;
-       unsigned long first, last;
+       struct amifb_par *par = &currentpar;
+       int i;
 
-       if (!n)
-               return;
+       custom.bplcon0 = par->bplcon0 & ~BPC0_LACE;
+       custom.bplcon2 = (IS_OCS ? 0 : BPC2_KILLEHB) | BPC2_PF2P2 | BPC2_PF1P2;
+       if (!IS_OCS) {
+               custom.bplcon3 = par->bplcon3;
+               if (IS_AGA)
+                       custom.bplcon4 = BPC4_ESPRM4 | BPC4_OSPRM4;
+               if (par->beamcon0 & BMC0_VARBEAMEN) {
+                       custom.htotal = htotal2hw(par->htotal);
+                       custom.hbstrt = hbstrt2hw(par->hbstrt);
+                       custom.hbstop = hbstop2hw(par->hbstop);
+                       custom.hsstrt = hsstrt2hw(par->hsstrt);
+                       custom.hsstop = hsstop2hw(par->hsstop);
+                       custom.hcenter = hcenter2hw(par->hcenter);
+                       custom.vtotal = vtotal2hw(par->vtotal);
+                       custom.vbstrt = vbstrt2hw(par->vbstrt);
+                       custom.vbstop = vbstop2hw(par->vbstop);
+                       custom.vsstrt = vsstrt2hw(par->vsstrt);
+                       custom.vsstop = vsstop2hw(par->vsstop);
+               }
+       }
+       if (!IS_OCS || par->hsstop)
+               custom.beamcon0 = par->beamcon0;
+       if (IS_AGA)
+               custom.fmode = par->fmode;
 
-#if BITS_PER_LONG == 64
-       val |= val << 32;
-#endif
+       /*
+        * The minimum period for audio depends on htotal
+        */
 
-       first = ~0UL >> dst_idx;
-       last = ~(~0UL >> ((dst_idx + n) % BITS_PER_LONG));
+       amiga_audio_min_period = div16(par->htotal);
 
-       if (dst_idx + n <= BITS_PER_LONG) {
-               // Single word
-               if (last)
-                       first &= last;
-               *dst = comp(val, *dst, first);
+       is_lace = par->bplcon0 & BPC0_LACE ? 1 : 0;
+#if 1
+       if (is_lace) {
+               i = custom.vposr >> 15;
        } else {
-               // Multiple destination words
-               // Leading bits
-               if (first) {
-                       *dst = comp(val, *dst, first);
-                       dst++;
-                       n -= BITS_PER_LONG - dst_idx;
-               }
-
-               // Main chunk
-               n /= BITS_PER_LONG;
-               while (n >= 8) {
-                       *dst++ = val;
-                       *dst++ = val;
-                       *dst++ = val;
-                       *dst++ = val;
-                       *dst++ = val;
-                       *dst++ = val;
-                       *dst++ = val;
-                       *dst++ = val;
-                       n -= 8;
-               }
-               while (n--)
-                       *dst++ = val;
-
-               // Trailing bits
-               if (last)
-                       *dst = comp(val, *dst, last);
+               custom.vposw = custom.vposr | 0x8000;
+               i = 1;
        }
+#else
+       i = 1;
+       custom.vposw = custom.vposr | 0x8000;
+#endif
+       custom.cop2lc = (u_short *)ZTWO_PADDR(copdisplay.list[currentcop][i]);
 }
 
-
        /*
-        *  Unaligned 32-bit pattern xor using 32/64-bit memory accesses
+        * (Un)Blank the screen (called by VBlank interrupt)
         */
 
-static void bitxor32(unsigned long *dst, int dst_idx, u32 pat, u32 n)
+static void ami_do_blank(void)
 {
-       unsigned long val = pat;
-       unsigned long first, last;
-
-       if (!n)
-               return;
-
-#if BITS_PER_LONG == 64
-       val |= val << 32;
+       struct amifb_par *par = &currentpar;
+#if defined(CONFIG_FB_AMIGA_AGA)
+       u_short bplcon3 = par->bplcon3;
 #endif
+       u_char red, green, blue;
 
-       first = ~0UL >> dst_idx;
-       last = ~(~0UL >> ((dst_idx + n) % BITS_PER_LONG));
-
-       if (dst_idx + n <= BITS_PER_LONG) {
-               // Single word
-               if (last)
-                       first &= last;
-               *dst = xor(val, *dst, first);
-       } else {
-               // Multiple destination words
-               // Leading bits
-               if (first) {
-                       *dst = xor(val, *dst, first);
-                       dst++;
-                       n -= BITS_PER_LONG - dst_idx;
+       if (do_blank > 0) {
+               custom.dmacon = DMAF_RASTER | DMAF_SPRITE;
+               red = green = blue = 0;
+               if (!IS_OCS && do_blank > 1) {
+                       switch (do_blank) {
+                       case FB_BLANK_VSYNC_SUSPEND:
+                               custom.hsstrt = hsstrt2hw(par->hsstrt);
+                               custom.hsstop = hsstop2hw(par->hsstop);
+                               custom.vsstrt = vsstrt2hw(par->vtotal + 4);
+                               custom.vsstop = vsstop2hw(par->vtotal + 4);
+                               break;
+                       case FB_BLANK_HSYNC_SUSPEND:
+                               custom.hsstrt = hsstrt2hw(par->htotal + 16);
+                               custom.hsstop = hsstop2hw(par->htotal + 16);
+                               custom.vsstrt = vsstrt2hw(par->vsstrt);
+                               custom.vsstop = vsstrt2hw(par->vsstop);
+                               break;
+                       case FB_BLANK_POWERDOWN:
+                               custom.hsstrt = hsstrt2hw(par->htotal + 16);
+                               custom.hsstop = hsstop2hw(par->htotal + 16);
+                               custom.vsstrt = vsstrt2hw(par->vtotal + 4);
+                               custom.vsstop = vsstop2hw(par->vtotal + 4);
+                               break;
+                       }
+                       if (!(par->beamcon0 & BMC0_VARBEAMEN)) {
+                               custom.htotal = htotal2hw(par->htotal);
+                               custom.vtotal = vtotal2hw(par->vtotal);
+                               custom.beamcon0 = BMC0_HARDDIS | BMC0_VARBEAMEN |
+                                                 BMC0_VARVSYEN | BMC0_VARHSYEN | BMC0_VARCSYEN;
+                       }
                }
-
-               // Main chunk
-               n /= BITS_PER_LONG;
-               while (n >= 4) {
-                       *dst++ ^= val;
-                       *dst++ ^= val;
-                       *dst++ ^= val;
-                       *dst++ ^= val;
-                       n -= 4;
+       } else {
+               custom.dmacon = DMAF_SETCLR | DMAF_RASTER | DMAF_SPRITE;
+               red = red0;
+               green = green0;
+               blue = blue0;
+               if (!IS_OCS) {
+                       custom.hsstrt = hsstrt2hw(par->hsstrt);
+                       custom.hsstop = hsstop2hw(par->hsstop);
+                       custom.vsstrt = vsstrt2hw(par->vsstrt);
+                       custom.vsstop = vsstop2hw(par->vsstop);
+                       custom.beamcon0 = par->beamcon0;
                }
-               while (n--)
-                       *dst++ ^= val;
-
-               // Trailing bits
-               if (last)
-                       *dst = xor(val, *dst, last);
        }
+#if defined(CONFIG_FB_AMIGA_AGA)
+       if (IS_AGA) {
+               custom.bplcon3 = bplcon3;
+               custom.color[0] = rgb2hw8_high(red, green, blue);
+               custom.bplcon3 = bplcon3 | BPC3_LOCT;
+               custom.color[0] = rgb2hw8_low(red, green, blue);
+               custom.bplcon3 = bplcon3;
+       } else
+#endif
+#if defined(CONFIG_FB_AMIGA_ECS)
+       if (par->bplcon0 & BPC0_SHRES) {
+               u_short color, mask;
+               int i;
+
+               mask = 0x3333;
+               color = rgb2hw2(red, green, blue);
+               for (i = 12; i >= 0; i -= 4)
+                       custom.color[i] = ecs_palette[i] = (ecs_palette[i] & mask) | color;
+               mask <<= 2; color >>= 2;
+               for (i = 3; i >= 0; i--)
+                       custom.color[i] = ecs_palette[i] = (ecs_palette[i] & mask) | color;
+       } else
+#endif
+               custom.color[0] = rgb2hw4(red, green, blue);
+       is_blanked = do_blank > 0 ? do_blank : 0;
 }
 
-static inline void fill_one_line(int bpp, unsigned long next_plane,
-                                unsigned long *dst, int dst_idx, u32 n,
-                                u32 color)
+static int ami_get_fix_cursorinfo(struct fb_fix_cursorinfo *fix)
 {
-       while (1) {
-               dst += dst_idx >> SHIFT_PER_LONG;
-               dst_idx &= (BITS_PER_LONG - 1);
-               bitfill32(dst, dst_idx, color & 1 ? ~0 : 0, n);
-               if (!--bpp)
-                       break;
-               color >>= 1;
-               dst_idx += next_plane * 8;
-       }
-}
+       struct amifb_par *par = &currentpar;
 
-static inline void xor_one_line(int bpp, unsigned long next_plane,
-                               unsigned long *dst, int dst_idx, u32 n,
-                               u32 color)
-{
-       while (color) {
-               dst += dst_idx >> SHIFT_PER_LONG;
-               dst_idx &= (BITS_PER_LONG - 1);
-               bitxor32(dst, dst_idx, color & 1 ? ~0 : 0, n);
-               if (!--bpp)
-                       break;
-               color >>= 1;
-               dst_idx += next_plane * 8;
-       }
+       fix->crsr_width = fix->crsr_xsize = par->crsr.width;
+       fix->crsr_height = fix->crsr_ysize = par->crsr.height;
+       fix->crsr_color1 = 17;
+       fix->crsr_color2 = 18;
+       return 0;
 }
 
-
-static void amifb_fillrect(struct fb_info *info,
-                          const struct fb_fillrect *rect)
+static int ami_get_var_cursorinfo(struct fb_var_cursorinfo *var, u_char __user *data)
 {
-       struct amifb_par *par = (struct amifb_par *)info->par;
-       int dst_idx, x2, y2;
-       unsigned long *dst;
-       u32 width, height;
-
-       if (!rect->width || !rect->height)
-               return;
-
-       /*
-        * We could use hardware clipping but on many cards you get around
-        * hardware clipping by writing to framebuffer directly.
-        * */
-       x2 = rect->dx + rect->width;
-       y2 = rect->dy + rect->height;
-       x2 = x2 < info->var.xres_virtual ? x2 : info->var.xres_virtual;
-       y2 = y2 < info->var.yres_virtual ? y2 : info->var.yres_virtual;
-       width = x2 - rect->dx;
-       height = y2 - rect->dy;
-
-       dst = (unsigned long *)
-               ((unsigned long)info->screen_base & ~(BYTES_PER_LONG - 1));
-       dst_idx = ((unsigned long)info->screen_base & (BYTES_PER_LONG - 1)) * 8;
-       dst_idx += rect->dy * par->next_line * 8 + rect->dx;
-       while (height--) {
-               switch (rect->rop) {
-               case ROP_COPY:
-                       fill_one_line(info->var.bits_per_pixel,
-                                     par->next_plane, dst, dst_idx, width,
-                                     rect->color);
-                       break;
+       struct amifb_par *par = &currentpar;
+       register u_short *lspr, *sspr;
+#ifdef __mc68000__
+       register u_long datawords asm ("d2");
+#else
+       register u_long datawords;
+#endif
+       register short delta;
+       register u_char color;
+       short height, width, bits, words;
+       int size, alloc;
 
-               case ROP_XOR:
-                       xor_one_line(info->var.bits_per_pixel, par->next_plane,
-                                    dst, dst_idx, width, rect->color);
-                       break;
+       size = par->crsr.height * par->crsr.width;
+       alloc = var->height * var->width;
+       var->height = par->crsr.height;
+       var->width = par->crsr.width;
+       var->xspot = par->crsr.spot_x;
+       var->yspot = par->crsr.spot_y;
+       if (size > var->height * var->width)
+               return -ENAMETOOLONG;
+       if (!access_ok(VERIFY_WRITE, data, size))
+               return -EFAULT;
+       delta = 1 << par->crsr.fmode;
+       lspr = lofsprite + (delta << 1);
+       if (par->bplcon0 & BPC0_LACE)
+               sspr = shfsprite + (delta << 1);
+       else
+               sspr = NULL;
+       for (height = (short)var->height - 1; height >= 0; height--) {
+               bits = 0; words = delta; datawords = 0;
+               for (width = (short)var->width - 1; width >= 0; width--) {
+                       if (bits == 0) {
+                               bits = 16; --words;
+#ifdef __mc68000__
+                               asm volatile ("movew %1@(%3:w:2),%0 ; swap %0 ; movew %1@+,%0"
+                                       : "=d" (datawords), "=a" (lspr) : "1" (lspr), "d" (delta));
+#else
+                               datawords = (*(lspr + delta) << 16) | (*lspr++);
+#endif
+                       }
+                       --bits;
+#ifdef __mc68000__
+                       asm volatile (
+                               "clrb %0 ; swap %1 ; lslw #1,%1 ; roxlb #1,%0 ; "
+                               "swap %1 ; lslw #1,%1 ; roxlb #1,%0"
+                               : "=d" (color), "=d" (datawords) : "1" (datawords));
+#else
+                       color = (((datawords >> 30) & 2)
+                                | ((datawords >> 15) & 1));
+                       datawords <<= 1;
+#endif
+                       put_user(color, data++);
                }
-               dst_idx += par->next_line * 8;
-       }
-}
-
-static inline void copy_one_line(int bpp, unsigned long next_plane,
-                                unsigned long *dst, int dst_idx,
-                                unsigned long *src, int src_idx, u32 n)
-{
-       while (1) {
-               dst += dst_idx >> SHIFT_PER_LONG;
-               dst_idx &= (BITS_PER_LONG - 1);
-               src += src_idx >> SHIFT_PER_LONG;
-               src_idx &= (BITS_PER_LONG - 1);
-               bitcpy(dst, dst_idx, src, src_idx, n);
-               if (!--bpp)
-                       break;
-               dst_idx += next_plane * 8;
-               src_idx += next_plane * 8;
-       }
-}
-
-static inline void copy_one_line_rev(int bpp, unsigned long next_plane,
-                                    unsigned long *dst, int dst_idx,
-                                    unsigned long *src, int src_idx, u32 n)
-{
-       while (1) {
-               dst += dst_idx >> SHIFT_PER_LONG;
-               dst_idx &= (BITS_PER_LONG - 1);
-               src += src_idx >> SHIFT_PER_LONG;
-               src_idx &= (BITS_PER_LONG - 1);
-               bitcpy_rev(dst, dst_idx, src, src_idx, n);
-               if (!--bpp)
-                       break;
-               dst_idx += next_plane * 8;
-               src_idx += next_plane * 8;
-       }
-}
-
-
-static void amifb_copyarea(struct fb_info *info,
-                          const struct fb_copyarea *area)
-{
-       struct amifb_par *par = (struct amifb_par *)info->par;
-       int x2, y2;
-       u32 dx, dy, sx, sy, width, height;
-       unsigned long *dst, *src;
-       int dst_idx, src_idx;
-       int rev_copy = 0;
-
-       /* clip the destination */
-       x2 = area->dx + area->width;
-       y2 = area->dy + area->height;
-       dx = area->dx > 0 ? area->dx : 0;
-       dy = area->dy > 0 ? area->dy : 0;
-       x2 = x2 < info->var.xres_virtual ? x2 : info->var.xres_virtual;
-       y2 = y2 < info->var.yres_virtual ? y2 : info->var.yres_virtual;
-       width = x2 - dx;
-       height = y2 - dy;
-
-       if (area->sx + dx < area->dx || area->sy + dy < area->dy)
-               return;
-
-       /* update sx,sy */
-       sx = area->sx + (dx - area->dx);
-       sy = area->sy + (dy - area->dy);
-
-       /* the source must be completely inside the virtual screen */
-       if (sx + width > info->var.xres_virtual ||
-                       sy + height > info->var.yres_virtual)
-               return;
-
-       if (dy > sy || (dy == sy && dx > sx)) {
-               dy += height;
-               sy += height;
-               rev_copy = 1;
-       }
-       dst = (unsigned long *)
-               ((unsigned long)info->screen_base & ~(BYTES_PER_LONG - 1));
-       src = dst;
-       dst_idx = ((unsigned long)info->screen_base & (BYTES_PER_LONG - 1)) * 8;
-       src_idx = dst_idx;
-       dst_idx += dy * par->next_line * 8 + dx;
-       src_idx += sy * par->next_line * 8 + sx;
-       if (rev_copy) {
-               while (height--) {
-                       dst_idx -= par->next_line * 8;
-                       src_idx -= par->next_line * 8;
-                       copy_one_line_rev(info->var.bits_per_pixel,
-                                         par->next_plane, dst, dst_idx, src,
-                                         src_idx, width);
+               if (bits > 0) {
+                       --words; ++lspr;
                }
-       } else {
-               while (height--) {
-                       copy_one_line(info->var.bits_per_pixel,
-                                     par->next_plane, dst, dst_idx, src,
-                                     src_idx, width);
-                       dst_idx += par->next_line * 8;
-                       src_idx += par->next_line * 8;
+               while (--words >= 0)
+                       ++lspr;
+#ifdef __mc68000__
+               asm volatile ("lea %0@(%4:w:2),%0 ; tstl %1 ; jeq 1f ; exg %0,%1\n1:"
+                       : "=a" (lspr), "=a" (sspr) : "0" (lspr), "1" (sspr), "d" (delta));
+#else
+               lspr += delta;
+               if (sspr) {
+                       u_short *tmp = lspr;
+                       lspr = sspr;
+                       sspr = tmp;
                }
+#endif
        }
+       return 0;
 }
 
-
-static inline void expand_one_line(int bpp, unsigned long next_plane,
-                                  unsigned long *dst, int dst_idx, u32 n,
-                                  const u8 *data, u32 bgcolor, u32 fgcolor)
+static int ami_set_var_cursorinfo(struct fb_var_cursorinfo *var, u_char __user *data)
 {
-       const unsigned long *src;
-       int src_idx;
+       struct amifb_par *par = &currentpar;
+       register u_short *lspr, *sspr;
+#ifdef __mc68000__
+       register u_long datawords asm ("d2");
+#else
+       register u_long datawords;
+#endif
+       register short delta;
+       u_short fmode;
+       short height, width, bits, words;
 
-       while (1) {
-               dst += dst_idx >> SHIFT_PER_LONG;
-               dst_idx &= (BITS_PER_LONG - 1);
-               if ((bgcolor ^ fgcolor) & 1) {
-                       src = (unsigned long *)
-                               ((unsigned long)data & ~(BYTES_PER_LONG - 1));
-                       src_idx = ((unsigned long)data & (BYTES_PER_LONG - 1)) * 8;
-                       if (fgcolor & 1)
-                               bitcpy(dst, dst_idx, src, src_idx, n);
-                       else
-                               bitcpy_not(dst, dst_idx, src, src_idx, n);
-                       /* set or clear */
-               } else
-                       bitfill32(dst, dst_idx, fgcolor & 1 ? ~0 : 0, n);
-               if (!--bpp)
-                       break;
-               bgcolor >>= 1;
-               fgcolor >>= 1;
-               dst_idx += next_plane * 8;
+       if (!var->width)
+               return -EINVAL;
+       else if (var->width <= 16)
+               fmode = TAG_FMODE_1;
+       else if (var->width <= 32)
+               fmode = TAG_FMODE_2;
+       else if (var->width <= 64)
+               fmode = TAG_FMODE_4;
+       else
+               return -EINVAL;
+       if (fmode > maxfmode)
+               return -EINVAL;
+       if (!var->height)
+               return -EINVAL;
+       if (!access_ok(VERIFY_READ, data, var->width * var->height))
+               return -EFAULT;
+       delta = 1 << fmode;
+       lofsprite = shfsprite = (u_short *)spritememory;
+       lspr = lofsprite + (delta << 1);
+       if (par->bplcon0 & BPC0_LACE) {
+               if (((var->height + 4) << fmode << 2) > SPRITEMEMSIZE)
+                       return -EINVAL;
+               memset(lspr, 0, (var->height + 4) << fmode << 2);
+               shfsprite += ((var->height + 5)&-2) << fmode;
+               sspr = shfsprite + (delta << 1);
+       } else {
+               if (((var->height + 2) << fmode << 2) > SPRITEMEMSIZE)
+                       return -EINVAL;
+               memset(lspr, 0, (var->height + 2) << fmode << 2);
+               sspr = NULL;
+       }
+       for (height = (short)var->height - 1; height >= 0; height--) {
+               bits = 16; words = delta; datawords = 0;
+               for (width = (short)var->width - 1; width >= 0; width--) {
+                       unsigned long tdata = 0;
+                       get_user(tdata, data);
+                       data++;
+#ifdef __mc68000__
+                       asm volatile (
+                               "lsrb #1,%2 ; roxlw #1,%0 ; swap %0 ; "
+                               "lsrb #1,%2 ; roxlw #1,%0 ; swap %0"
+                               : "=d" (datawords)
+                               : "0" (datawords), "d" (tdata));
+#else
+                       datawords = ((datawords << 1) & 0xfffefffe);
+                       datawords |= tdata & 1;
+                       datawords |= (tdata & 2) << (16 - 1);
+#endif
+                       if (--bits == 0) {
+                               bits = 16; --words;
+#ifdef __mc68000__
+                               asm volatile ("swap %2 ; movew %2,%0@(%3:w:2) ; swap %2 ; movew %2,%0@+"
+                                       : "=a" (lspr) : "0" (lspr), "d" (datawords), "d" (delta));
+#else
+                               *(lspr + delta) = (u_short) (datawords >> 16);
+                               *lspr++ = (u_short) (datawords & 0xffff);
+#endif
+                       }
+               }
+               if (bits < 16) {
+                       --words;
+#ifdef __mc68000__
+                       asm volatile (
+                               "swap %2 ; lslw %4,%2 ; movew %2,%0@(%3:w:2) ; "
+                               "swap %2 ; lslw %4,%2 ; movew %2,%0@+"
+                               : "=a" (lspr) : "0" (lspr), "d" (datawords), "d" (delta), "d" (bits));
+#else
+                       *(lspr + delta) = (u_short) (datawords >> (16 + bits));
+                       *lspr++ = (u_short) ((datawords & 0x0000ffff) >> bits);
+#endif
+               }
+               while (--words >= 0) {
+#ifdef __mc68000__
+                       asm volatile ("moveql #0,%%d0 ; movew %%d0,%0@(%2:w:2) ; movew %%d0,%0@+"
+                               : "=a" (lspr) : "0" (lspr), "d" (delta) : "d0");
+#else
+                       *(lspr + delta) = 0;
+                       *lspr++ = 0;
+#endif
+               }
+#ifdef __mc68000__
+               asm volatile ("lea %0@(%4:w:2),%0 ; tstl %1 ; jeq 1f ; exg %0,%1\n1:"
+                       : "=a" (lspr), "=a" (sspr) : "0" (lspr), "1" (sspr), "d" (delta));
+#else
+               lspr += delta;
+               if (sspr) {
+                       u_short *tmp = lspr;
+                       lspr = sspr;
+                       sspr = tmp;
+               }
+#endif
+       }
+       par->crsr.height = var->height;
+       par->crsr.width = var->width;
+       par->crsr.spot_x = var->xspot;
+       par->crsr.spot_y = var->yspot;
+       par->crsr.fmode = fmode;
+       if (IS_AGA) {
+               par->fmode &= ~(FMODE_SPAGEM | FMODE_SPR32);
+               par->fmode |= sprfetchmode[fmode];
+               custom.fmode = par->fmode;
        }
+       return 0;
 }
 
+static int ami_get_cursorstate(struct fb_cursorstate *state)
+{
+       struct amifb_par *par = &currentpar;
+
+       state->xoffset = par->crsr.crsr_x;
+       state->yoffset = par->crsr.crsr_y;
+       state->mode = cursormode;
+       return 0;
+}
 
-static void amifb_imageblit(struct fb_info *info, const struct fb_image *image)
+static int ami_set_cursorstate(struct fb_cursorstate *state)
 {
-       struct amifb_par *par = (struct amifb_par *)info->par;
-       int x2, y2;
-       unsigned long *dst;
-       int dst_idx;
-       const char *src;
-       u32 dx, dy, width, height, pitch;
+       struct amifb_par *par = &currentpar;
 
-       /*
-        * We could use hardware clipping but on many cards you get around
-        * hardware clipping by writing to framebuffer directly like we are
-        * doing here.
-        */
-       x2 = image->dx + image->width;
-       y2 = image->dy + image->height;
-       dx = image->dx;
-       dy = image->dy;
-       x2 = x2 < info->var.xres_virtual ? x2 : info->var.xres_virtual;
-       y2 = y2 < info->var.yres_virtual ? y2 : info->var.yres_virtual;
-       width  = x2 - dx;
-       height = y2 - dy;
+       par->crsr.crsr_x = state->xoffset;
+       par->crsr.crsr_y = state->yoffset;
+       if ((cursormode = state->mode) == FB_CURSOR_OFF)
+               cursorstate = -1;
+       do_cursor = 1;
+       return 0;
+}
 
-       if (image->depth == 1) {
-               dst = (unsigned long *)
-                       ((unsigned long)info->screen_base & ~(BYTES_PER_LONG - 1));
-               dst_idx = ((unsigned long)info->screen_base & (BYTES_PER_LONG - 1)) * 8;
-               dst_idx += dy * par->next_line * 8 + dx;
-               src = image->data;
-               pitch = (image->width + 7) / 8;
-               while (height--) {
-                       expand_one_line(info->var.bits_per_pixel,
-                                       par->next_plane, dst, dst_idx, width,
-                                       src, image->bg_color,
-                                       image->fg_color);
-                       dst_idx += par->next_line * 8;
-                       src += pitch;
+static void ami_set_sprite(void)
+{
+       struct amifb_par *par = &currentpar;
+       copins *copl, *cops;
+       u_short hs, vs, ve;
+       u_long pl, ps, pt;
+       short mx, my;
+
+       cops = copdisplay.list[currentcop][0];
+       copl = copdisplay.list[currentcop][1];
+       ps = pl = ZTWO_PADDR(dummysprite);
+       mx = par->crsr.crsr_x - par->crsr.spot_x;
+       my = par->crsr.crsr_y - par->crsr.spot_y;
+       if (!(par->vmode & FB_VMODE_YWRAP)) {
+               mx -= par->xoffset;
+               my -= par->yoffset;
+       }
+       if (!is_blanked && cursorstate > 0 && par->crsr.height > 0 &&
+           mx > -(short)par->crsr.width && mx < par->xres &&
+           my > -(short)par->crsr.height && my < par->yres) {
+               pl = ZTWO_PADDR(lofsprite);
+               hs = par->diwstrt_h + (mx << par->clk_shift) - 4;
+               vs = par->diwstrt_v + (my << par->line_shift);
+               ve = vs + (par->crsr.height << par->line_shift);
+               if (par->bplcon0 & BPC0_LACE) {
+                       ps = ZTWO_PADDR(shfsprite);
+                       lofsprite[0] = spr2hw_pos(vs, hs);
+                       shfsprite[0] = spr2hw_pos(vs + 1, hs);
+                       if (mod2(vs)) {
+                               lofsprite[1 << par->crsr.fmode] = spr2hw_ctl(vs, hs, ve);
+                               shfsprite[1 << par->crsr.fmode] = spr2hw_ctl(vs + 1, hs, ve + 1);
+                               pt = pl; pl = ps; ps = pt;
+                       } else {
+                               lofsprite[1 << par->crsr.fmode] = spr2hw_ctl(vs, hs, ve + 1);
+                               shfsprite[1 << par->crsr.fmode] = spr2hw_ctl(vs + 1, hs, ve);
+                       }
+               } else {
+                       lofsprite[0] = spr2hw_pos(vs, hs) | (IS_AGA && (par->fmode & FMODE_BSCAN2) ? 0x80 : 0);
+                       lofsprite[1 << par->crsr.fmode] = spr2hw_ctl(vs, hs, ve);
                }
-       } else {
-               c2p_planar(info->screen_base, image->data, dx, dy, width,
-                          height, par->next_line, par->next_plane,
-                          image->width, info->var.bits_per_pixel);
+       }
+       copl[cop_spr0ptrh].w[1] = highw(pl);
+       copl[cop_spr0ptrl].w[1] = loww(pl);
+       if (par->bplcon0 & BPC0_LACE) {
+               cops[cop_spr0ptrh].w[1] = highw(ps);
+               cops[cop_spr0ptrl].w[1] = loww(ps);
        }
 }
 
 
        /*
-        * Amiga Frame Buffer Specific ioctls
+        * Initialise the Copper Initialisation List
         */
 
-static int amifb_ioctl(struct fb_info *info,
-                      unsigned int cmd, unsigned long arg)
+static void __init ami_init_copper(void)
 {
-       union {
-               struct fb_fix_cursorinfo fix;
-               struct fb_var_cursorinfo var;
-               struct fb_cursorstate state;
-       } crsr;
-       void __user *argp = (void __user *)arg;
+       copins *cop = copdisplay.init;
+       u_long p;
        int i;
 
-       switch (cmd) {
-       case FBIOGET_FCURSORINFO:
-               i = ami_get_fix_cursorinfo(&crsr.fix);
-               if (i)
-                       return i;
-               return copy_to_user(argp, &crsr.fix,
-                                   sizeof(crsr.fix)) ? -EFAULT : 0;
+       if (!IS_OCS) {
+               (cop++)->l = CMOVE(BPC0_COLOR | BPC0_SHRES | BPC0_ECSENA, bplcon0);
+               (cop++)->l = CMOVE(0x0181, diwstrt);
+               (cop++)->l = CMOVE(0x0281, diwstop);
+               (cop++)->l = CMOVE(0x0000, diwhigh);
+       } else
+               (cop++)->l = CMOVE(BPC0_COLOR, bplcon0);
+       p = ZTWO_PADDR(dummysprite);
+       for (i = 0; i < 8; i++) {
+               (cop++)->l = CMOVE(0, spr[i].pos);
+               (cop++)->l = CMOVE(highw(p), sprpt[i]);
+               (cop++)->l = CMOVE2(loww(p), sprpt[i]);
+       }
 
-       case FBIOGET_VCURSORINFO:
-               i = ami_get_var_cursorinfo(&crsr.var,
-                       ((struct fb_var_cursorinfo __user *)arg)->data);
-               if (i)
-                       return i;
-               return copy_to_user(argp, &crsr.var,
-                                   sizeof(crsr.var)) ? -EFAULT : 0;
+       (cop++)->l = CMOVE(IF_SETCLR | IF_COPER, intreq);
+       copdisplay.wait = cop;
+       (cop++)->l = CEND;
+       (cop++)->l = CMOVE(0, copjmp2);
+       cop->l = CEND;
 
-       case FBIOPUT_VCURSORINFO:
-               if (copy_from_user(&crsr.var, argp, sizeof(crsr.var)))
-                       return -EFAULT;
-               return ami_set_var_cursorinfo(&crsr.var,
-                       ((struct fb_var_cursorinfo __user *)arg)->data);
-
-       case FBIOGET_CURSORSTATE:
-               i = ami_get_cursorstate(&crsr.state);
-               if (i)
-                       return i;
-               return copy_to_user(argp, &crsr.state,
-                                   sizeof(crsr.state)) ? -EFAULT : 0;
-
-       case FBIOPUT_CURSORSTATE:
-               if (copy_from_user(&crsr.state, argp, sizeof(crsr.state)))
-                       return -EFAULT;
-               return ami_set_cursorstate(&crsr.state);
-       }
-       return -EINVAL;
+       custom.cop1lc = (u_short *)ZTWO_PADDR(copdisplay.init);
+       custom.copjmp1 = 0;
 }
 
-
-       /*
-        * Allocate, Clear and Align a Block of Chip Memory
-        */
-
-static void *aligned_chipptr;
-
-static inline u_long __init chipalloc(u_long size)
+static void ami_reinit_copper(void)
 {
-       aligned_chipptr = amiga_chip_alloc(size, "amifb [RAM]");
-       if (!aligned_chipptr) {
-               pr_err("amifb: No Chip RAM for frame buffer");
-               return 0;
-       }
-       memset(aligned_chipptr, 0, size);
-       return (u_long)aligned_chipptr;
-}
+       struct amifb_par *par = &currentpar;
 
-static inline void chipfree(void)
-{
-       if (aligned_chipptr)
-               amiga_chip_free(aligned_chipptr);
+       copdisplay.init[cip_bplcon0].w[1] = ~(BPC0_BPU3 | BPC0_BPU2 | BPC0_BPU1 | BPC0_BPU0) & par->bplcon0;
+       copdisplay.wait->l = CWAIT(32, par->diwstrt_v - 4);
 }
 
 
        /*
-        * Initialisation
+        * Rebuild the Copper List
+        *
+        * We only change the things that are not static
         */
 
-static int __init amifb_probe(struct platform_device *pdev)
+static void ami_rebuild_copper(void)
 {
-       int tag, i, err = 0;
-       u_long chipptr;
-       u_int defmode;
-
-#ifndef MODULE
-       char *option = NULL;
+       struct amifb_par *par = &currentpar;
+       copins *copl, *cops;
+       u_short line, h_end1, h_end2;
+       short i;
+       u_long p;
 
-       if (fb_get_options("amifb", &option)) {
-               amifb_video_off();
-               return -ENODEV;
-       }
-       amifb_setup(option);
-#endif
-       custom.dmacon = DMAF_ALL | DMAF_MASTER;
+       if (IS_AGA && maxfmode + par->clk_shift == 0)
+               h_end1 = par->diwstrt_h - 64;
+       else
+               h_end1 = par->htotal - 32;
+       h_end2 = par->ddfstop + 64;
 
-       switch (amiga_chipset) {
-#ifdef CONFIG_FB_AMIGA_OCS
-       case CS_OCS:
-               strcat(fb_info.fix.id, "OCS");
-default_chipset:
-               chipset = TAG_OCS;
-               maxdepth[TAG_SHRES] = 0;        /* OCS means no SHRES */
-               maxdepth[TAG_HIRES] = 4;
-               maxdepth[TAG_LORES] = 6;
-               maxfmode = TAG_FMODE_1;
-               defmode = amiga_vblank == 50 ? DEFMODE_PAL : DEFMODE_NTSC;
-               fb_info.fix.smem_len = VIDEOMEMSIZE_OCS;
-               break;
-#endif /* CONFIG_FB_AMIGA_OCS */
+       ami_set_sprite();
 
-#ifdef CONFIG_FB_AMIGA_ECS
-       case CS_ECS:
-               strcat(fb_info.fix.id, "ECS");
-               chipset = TAG_ECS;
-               maxdepth[TAG_SHRES] = 2;
-               maxdepth[TAG_HIRES] = 4;
-               maxdepth[TAG_LORES] = 6;
-               maxfmode = TAG_FMODE_1;
-               if (AMIGAHW_PRESENT(AMBER_FF))
-                       defmode = amiga_vblank == 50 ? DEFMODE_AMBER_PAL
-                                                    : DEFMODE_AMBER_NTSC;
-               else
-                       defmode = amiga_vblank == 50 ? DEFMODE_PAL
-                                                    : DEFMODE_NTSC;
-               if (amiga_chip_avail() - CHIPRAM_SAFETY_LIMIT >
-                   VIDEOMEMSIZE_ECS_2M)
-                       fb_info.fix.smem_len = VIDEOMEMSIZE_ECS_2M;
-               else
-                       fb_info.fix.smem_len = VIDEOMEMSIZE_ECS_1M;
-               break;
-#endif /* CONFIG_FB_AMIGA_ECS */
+       copl = copdisplay.rebuild[1];
+       p = par->bplpt0;
+       if (par->vmode & FB_VMODE_YWRAP) {
+               if ((par->vyres - par->yoffset) != 1 || !mod2(par->diwstrt_v)) {
+                       if (par->yoffset > par->vyres - par->yres) {
+                               for (i = 0; i < (short)par->bpp; i++, p += par->next_plane) {
+                                       (copl++)->l = CMOVE(highw(p), bplpt[i]);
+                                       (copl++)->l = CMOVE2(loww(p), bplpt[i]);
+                               }
+                               line = par->diwstrt_v + ((par->vyres - par->yoffset) << par->line_shift) - 1;
+                               while (line >= 512) {
+                                       (copl++)->l = CWAIT(h_end1, 510);
+                                       line -= 512;
+                               }
+                               if (line >= 510 && IS_AGA && maxfmode + par->clk_shift == 0)
+                                       (copl++)->l = CWAIT(h_end1, line);
+                               else
+                                       (copl++)->l = CWAIT(h_end2, line);
+                               p = par->bplpt0wrap;
+                       }
+               } else
+                       p = par->bplpt0wrap;
+       }
+       for (i = 0; i < (short)par->bpp; i++, p += par->next_plane) {
+               (copl++)->l = CMOVE(highw(p), bplpt[i]);
+               (copl++)->l = CMOVE2(loww(p), bplpt[i]);
+       }
+       copl->l = CEND;
 
-#ifdef CONFIG_FB_AMIGA_AGA
-       case CS_AGA:
-               strcat(fb_info.fix.id, "AGA");
-               chipset = TAG_AGA;
-               maxdepth[TAG_SHRES] = 8;
-               maxdepth[TAG_HIRES] = 8;
-               maxdepth[TAG_LORES] = 8;
-               maxfmode = TAG_FMODE_4;
-               defmode = DEFMODE_AGA;
-               if (amiga_chip_avail() - CHIPRAM_SAFETY_LIMIT >
-                   VIDEOMEMSIZE_AGA_2M)
-                       fb_info.fix.smem_len = VIDEOMEMSIZE_AGA_2M;
+       if (par->bplcon0 & BPC0_LACE) {
+               cops = copdisplay.rebuild[0];
+               p = par->bplpt0;
+               if (mod2(par->diwstrt_v))
+                       p -= par->next_line;
                else
-                       fb_info.fix.smem_len = VIDEOMEMSIZE_AGA_1M;
-               break;
-#endif /* CONFIG_FB_AMIGA_AGA */
-
-       default:
-#ifdef CONFIG_FB_AMIGA_OCS
-               printk("Unknown graphics chipset, defaulting to OCS\n");
-               strcat(fb_info.fix.id, "Unknown");
-               goto default_chipset;
-#else /* CONFIG_FB_AMIGA_OCS */
-               err = -ENODEV;
-               goto amifb_error;
-#endif /* CONFIG_FB_AMIGA_OCS */
-               break;
+                       p += par->next_line;
+               if (par->vmode & FB_VMODE_YWRAP) {
+                       if ((par->vyres - par->yoffset) != 1 || mod2(par->diwstrt_v)) {
+                               if (par->yoffset > par->vyres - par->yres + 1) {
+                                       for (i = 0; i < (short)par->bpp; i++, p += par->next_plane) {
+                                               (cops++)->l = CMOVE(highw(p), bplpt[i]);
+                                               (cops++)->l = CMOVE2(loww(p), bplpt[i]);
+                                       }
+                                       line = par->diwstrt_v + ((par->vyres - par->yoffset) << par->line_shift) - 2;
+                                       while (line >= 512) {
+                                               (cops++)->l = CWAIT(h_end1, 510);
+                                               line -= 512;
+                                       }
+                                       if (line > 510 && IS_AGA && maxfmode + par->clk_shift == 0)
+                                               (cops++)->l = CWAIT(h_end1, line);
+                                       else
+                                               (cops++)->l = CWAIT(h_end2, line);
+                                       p = par->bplpt0wrap;
+                                       if (mod2(par->diwstrt_v + par->vyres -
+                                           par->yoffset))
+                                               p -= par->next_line;
+                                       else
+                                               p += par->next_line;
+                               }
+                       } else
+                               p = par->bplpt0wrap - par->next_line;
+               }
+               for (i = 0; i < (short)par->bpp; i++, p += par->next_plane) {
+                       (cops++)->l = CMOVE(highw(p), bplpt[i]);
+                       (cops++)->l = CMOVE2(loww(p), bplpt[i]);
+               }
+               cops->l = CEND;
        }
+}
 
-       /*
-        * Calculate the Pixel Clock Values for this Machine
-        */
-
-       {
-       u_long tmp = DIVUL(200000000000ULL, amiga_eclock);
-
-       pixclock[TAG_SHRES] = (tmp + 4) / 8;    /* SHRES:  35 ns / 28 MHz */
-       pixclock[TAG_HIRES] = (tmp + 2) / 4;    /* HIRES:  70 ns / 14 MHz */
-       pixclock[TAG_LORES] = (tmp + 1) / 2;    /* LORES: 140 ns /  7 MHz */
-       }
 
        /*
-        * Replace the Tag Values with the Real Pixel Clock Values
+        * Build the Copper List
         */
 
-       for (i = 0; i < NUM_TOTAL_MODES; i++) {
-               struct fb_videomode *mode = &ami_modedb[i];
-               tag = mode->pixclock;
-               if (tag == TAG_SHRES || tag == TAG_HIRES || tag == TAG_LORES) {
-                       mode->pixclock = pixclock[tag];
-               }
-       }
+static void ami_build_copper(void)
+{
+       struct amifb_par *par = &currentpar;
+       copins *copl, *cops;
+       u_long p;
 
-       /*
-        *  These monitor specs are for a typical Amiga monitor (e.g. A1960)
-        */
-       if (fb_info.monspecs.hfmin == 0) {
-               fb_info.monspecs.hfmin = 15000;
-               fb_info.monspecs.hfmax = 38000;
-               fb_info.monspecs.vfmin = 49;
-               fb_info.monspecs.vfmax = 90;
-       }
+       currentcop = 1 - currentcop;
 
-       fb_info.fbops = &amifb_ops;
-       fb_info.par = &currentpar;
-       fb_info.flags = FBINFO_DEFAULT;
-       fb_info.device = &pdev->dev;
+       copl = copdisplay.list[currentcop][1];
 
-       if (!fb_find_mode(&fb_info.var, &fb_info, mode_option, ami_modedb,
-                         NUM_TOTAL_MODES, &ami_modedb[defmode], 4)) {
-               err = -EINVAL;
-               goto amifb_error;
-       }
+       (copl++)->l = CWAIT(0, 10);
+       (copl++)->l = CMOVE(par->bplcon0, bplcon0);
+       (copl++)->l = CMOVE(0, sprpt[0]);
+       (copl++)->l = CMOVE2(0, sprpt[0]);
 
-       fb_videomode_to_modelist(ami_modedb, NUM_TOTAL_MODES,
-                                &fb_info.modelist);
+       if (par->bplcon0 & BPC0_LACE) {
+               cops = copdisplay.list[currentcop][0];
 
-       round_down_bpp = 0;
-       chipptr = chipalloc(fb_info.fix.smem_len + SPRITEMEMSIZE +
-                           DUMMYSPRITEMEMSIZE + COPINITSIZE +
-                           4 * COPLISTSIZE);
-       if (!chipptr) {
-               err = -ENOMEM;
-               goto amifb_error;
+               (cops++)->l = CWAIT(0, 10);
+               (cops++)->l = CMOVE(par->bplcon0, bplcon0);
+               (cops++)->l = CMOVE(0, sprpt[0]);
+               (cops++)->l = CMOVE2(0, sprpt[0]);
+
+               (copl++)->l = CMOVE(diwstrt2hw(par->diwstrt_h, par->diwstrt_v + 1), diwstrt);
+               (copl++)->l = CMOVE(diwstop2hw(par->diwstop_h, par->diwstop_v + 1), diwstop);
+               (cops++)->l = CMOVE(diwstrt2hw(par->diwstrt_h, par->diwstrt_v), diwstrt);
+               (cops++)->l = CMOVE(diwstop2hw(par->diwstop_h, par->diwstop_v), diwstop);
+               if (!IS_OCS) {
+                       (copl++)->l = CMOVE(diwhigh2hw(par->diwstrt_h, par->diwstrt_v + 1,
+                                           par->diwstop_h, par->diwstop_v + 1), diwhigh);
+                       (cops++)->l = CMOVE(diwhigh2hw(par->diwstrt_h, par->diwstrt_v,
+                                           par->diwstop_h, par->diwstop_v), diwhigh);
+#if 0
+                       if (par->beamcon0 & BMC0_VARBEAMEN) {
+                               (copl++)->l = CMOVE(vtotal2hw(par->vtotal), vtotal);
+                               (copl++)->l = CMOVE(vbstrt2hw(par->vbstrt + 1), vbstrt);
+                               (copl++)->l = CMOVE(vbstop2hw(par->vbstop + 1), vbstop);
+                               (cops++)->l = CMOVE(vtotal2hw(par->vtotal), vtotal);
+                               (cops++)->l = CMOVE(vbstrt2hw(par->vbstrt), vbstrt);
+                               (cops++)->l = CMOVE(vbstop2hw(par->vbstop), vbstop);
+                       }
+#endif
+               }
+               p = ZTWO_PADDR(copdisplay.list[currentcop][0]);
+               (copl++)->l = CMOVE(highw(p), cop2lc);
+               (copl++)->l = CMOVE2(loww(p), cop2lc);
+               p = ZTWO_PADDR(copdisplay.list[currentcop][1]);
+               (cops++)->l = CMOVE(highw(p), cop2lc);
+               (cops++)->l = CMOVE2(loww(p), cop2lc);
+               copdisplay.rebuild[0] = cops;
+       } else {
+               (copl++)->l = CMOVE(diwstrt2hw(par->diwstrt_h, par->diwstrt_v), diwstrt);
+               (copl++)->l = CMOVE(diwstop2hw(par->diwstop_h, par->diwstop_v), diwstop);
+               if (!IS_OCS) {
+                       (copl++)->l = CMOVE(diwhigh2hw(par->diwstrt_h, par->diwstrt_v,
+                                           par->diwstop_h, par->diwstop_v), diwhigh);
+#if 0
+                       if (par->beamcon0 & BMC0_VARBEAMEN) {
+                               (copl++)->l = CMOVE(vtotal2hw(par->vtotal), vtotal);
+                               (copl++)->l = CMOVE(vbstrt2hw(par->vbstrt), vbstrt);
+                               (copl++)->l = CMOVE(vbstop2hw(par->vbstop), vbstop);
+                       }
+#endif
+               }
        }
+       copdisplay.rebuild[1] = copl;
 
-       assignchunk(videomemory, u_long, chipptr, fb_info.fix.smem_len);
-       assignchunk(spritememory, u_long, chipptr, SPRITEMEMSIZE);
-       assignchunk(dummysprite, u_short *, chipptr, DUMMYSPRITEMEMSIZE);
-       assignchunk(copdisplay.init, copins *, chipptr, COPINITSIZE);
-       assignchunk(copdisplay.list[0][0], copins *, chipptr, COPLISTSIZE);
-       assignchunk(copdisplay.list[0][1], copins *, chipptr, COPLISTSIZE);
-       assignchunk(copdisplay.list[1][0], copins *, chipptr, COPLISTSIZE);
-       assignchunk(copdisplay.list[1][1], copins *, chipptr, COPLISTSIZE);
+       ami_update_par();
+       ami_rebuild_copper();
+}
 
-       /*
-        * access the videomem with writethrough cache
-        */
-       fb_info.fix.smem_start = (u_long)ZTWO_PADDR(videomemory);
-       videomemory = (u_long)ioremap_writethrough(fb_info.fix.smem_start,
-                                                  fb_info.fix.smem_len);
-       if (!videomemory) {
-               printk("amifb: WARNING! unable to map videomem cached writethrough\n");
-               fb_info.screen_base = (char *)ZTWO_VADDR(fb_info.fix.smem_start);
-       } else
-               fb_info.screen_base = (char *)videomemory;
 
-       memset(dummysprite, 0, DUMMYSPRITEMEMSIZE);
+static void __init amifb_setup_mcap(char *spec)
+{
+       char *p;
+       int vmin, vmax, hmin, hmax;
 
-       /*
-        * Enable Display DMA
+       /* Format for monitor capabilities is: <Vmin>;<Vmax>;<Hmin>;<Hmax>
+        * <V*> vertical freq. in Hz
+        * <H*> horizontal freq. in kHz
         */
 
-       custom.dmacon = DMAF_SETCLR | DMAF_MASTER | DMAF_RASTER | DMAF_COPPER |
-                       DMAF_BLITTER | DMAF_SPRITE;
-
-       /*
-        * Make sure the Copper has something to do
-        */
+       if (!(p = strsep(&spec, ";")) || !*p)
+               return;
+       vmin = simple_strtoul(p, NULL, 10);
+       if (vmin <= 0)
+               return;
+       if (!(p = strsep(&spec, ";")) || !*p)
+               return;
+       vmax = simple_strtoul(p, NULL, 10);
+       if (vmax <= 0 || vmax <= vmin)
+               return;
+       if (!(p = strsep(&spec, ";")) || !*p)
+               return;
+       hmin = 1000 * simple_strtoul(p, NULL, 10);
+       if (hmin <= 0)
+               return;
+       if (!(p = strsep(&spec, "")) || !*p)
+               return;
+       hmax = 1000 * simple_strtoul(p, NULL, 10);
+       if (hmax <= 0 || hmax <= hmin)
+               return;
 
-       ami_init_copper();
+       fb_info.monspecs.vfmin = vmin;
+       fb_info.monspecs.vfmax = vmax;
+       fb_info.monspecs.hfmin = hmin;
+       fb_info.monspecs.hfmax = hmax;
+}
 
-       if (request_irq(IRQ_AMIGA_COPPER, amifb_interrupt, 0,
-                       "fb vertb handler", &currentpar)) {
-               err = -EBUSY;
-               goto amifb_error;
-       }
+int __init amifb_setup(char *options)
+{
+       char *this_opt;
 
-       err = fb_alloc_cmap(&fb_info.cmap, 1 << fb_info.var.bits_per_pixel, 0);
-       if (err)
-               goto amifb_error;
+       if (!options || !*options)
+               return 0;
 
-       if (register_framebuffer(&fb_info) < 0) {
-               err = -EINVAL;
-               goto amifb_error;
+       while ((this_opt = strsep(&options, ",")) != NULL) {
+               if (!*this_opt)
+                       continue;
+               if (!strcmp(this_opt, "inverse")) {
+                       amifb_inverse = 1;
+                       fb_invert_cmaps();
+               } else if (!strcmp(this_opt, "ilbm"))
+                       amifb_ilbm = 1;
+               else if (!strncmp(this_opt, "monitorcap:", 11))
+                       amifb_setup_mcap(this_opt + 11);
+               else if (!strncmp(this_opt, "fstart:", 7))
+                       min_fstrt = simple_strtoul(this_opt + 7, NULL, 0);
+               else
+                       mode_option = this_opt;
        }
 
-       printk("fb%d: %s frame buffer device, using %dK of video memory\n",
-              fb_info.node, fb_info.fix.id, fb_info.fix.smem_len>>10);
+       if (min_fstrt < 48)
+               min_fstrt = 48;
 
        return 0;
-
-amifb_error:
-       amifb_deinit(pdev);
-       return err;
-}
-
-static void amifb_deinit(struct platform_device *pdev)
-{
-       if (fb_info.cmap.len)
-               fb_dealloc_cmap(&fb_info.cmap);
-       chipfree();
-       if (videomemory)
-               iounmap((void *)videomemory);
-       custom.dmacon = DMAF_ALL | DMAF_MASTER;
 }
 
 
-       /*
-        * Blank the display.
-        */
-
-static int amifb_blank(int blank, struct fb_info *info)
+static int amifb_check_var(struct fb_var_screeninfo *var,
+                          struct fb_info *info)
 {
-       do_blank = blank ? blank : -1;
+       int err;
+       struct amifb_par par;
+
+       /* Validate wanted screen parameters */
+       if ((err = ami_decode_var(var, &par)))
+               return err;
 
+       /* Encode (possibly rounded) screen parameters */
+       ami_encode_var(var, &par);
        return 0;
 }
 
-       /*
-        * Flash the cursor (called by VBlank interrupt)
-        */
 
-static int flash_cursor(void)
+static int amifb_set_par(struct fb_info *info)
 {
-       static int cursorcount = 1;
+       struct amifb_par *par = (struct amifb_par *)info->par;
 
-       if (cursormode == FB_CURSOR_FLASH) {
-               if (!--cursorcount) {
-                       cursorstate = -cursorstate;
-                       cursorcount = cursorrate;
-                       if (!is_blanked)
-                               return 1;
-               }
-       }
-       return 0;
-}
+       do_vmode_pan = 0;
+       do_vmode_full = 0;
 
-       /*
-        * VBlank Display Interrupt
-        */
+       /* Decode wanted screen parameters */
+       ami_decode_var(&info->var, par);
 
-static irqreturn_t amifb_interrupt(int irq, void *dev_id)
-{
-       if (do_vmode_pan || do_vmode_full)
-               ami_update_display();
+       /* Set new videomode */
+       ami_build_copper();
 
-       if (do_vmode_full)
-               ami_init_display();
+       /* Set VBlank trigger */
+       do_vmode_full = 1;
 
-       if (do_vmode_pan) {
-               flash_cursor();
-               ami_rebuild_copper();
-               do_cursor = do_vmode_pan = 0;
-       } else if (do_cursor) {
-               flash_cursor();
-               ami_set_sprite();
-               do_cursor = 0;
+       /* Update fix for new screen parameters */
+       if (par->bpp == 1) {
+               info->fix.type = FB_TYPE_PACKED_PIXELS;
+               info->fix.type_aux = 0;
+       } else if (amifb_ilbm) {
+               info->fix.type = FB_TYPE_INTERLEAVED_PLANES;
+               info->fix.type_aux = par->next_line;
        } else {
-               if (flash_cursor())
-                       ami_set_sprite();
+               info->fix.type = FB_TYPE_PLANES;
+               info->fix.type_aux = 0;
        }
+       info->fix.line_length = div8(upx(16 << maxfmode, par->vxres));
 
-       if (do_blank) {
-               ami_do_blank();
-               do_blank = 0;
+       if (par->vmode & FB_VMODE_YWRAP) {
+               info->fix.ywrapstep = 1;
+               info->fix.xpanstep = 0;
+               info->fix.ypanstep = 0;
+               info->flags = FBINFO_DEFAULT | FBINFO_HWACCEL_YWRAP |
+                       FBINFO_READS_FAST; /* override SCROLL_REDRAW */
+       } else {
+               info->fix.ywrapstep = 0;
+               if (par->vmode & FB_VMODE_SMOOTH_XPAN)
+                       info->fix.xpanstep = 1;
+               else
+                       info->fix.xpanstep = 16 << maxfmode;
+               info->fix.ypanstep = 1;
+               info->flags = FBINFO_DEFAULT | FBINFO_HWACCEL_YPAN;
        }
+       return 0;
+}
 
-       if (do_vmode_full) {
-               ami_reinit_copper();
-               do_vmode_full = 0;
-       }
-       return IRQ_HANDLED;
-}
-
-/* --------------------------- Hardware routines --------------------------- */
 
        /*
-        * Get the video params out of `var'. If a value doesn't fit, round
-        * it up, if it's too big, return -EINVAL.
+        * Set a single color register. The values supplied are already
+        * rounded down to the hardware's capabilities (according to the
+        * entries in the var structure). Return != 0 for invalid regno.
         */
 
-static int ami_decode_var(struct fb_var_screeninfo *var,
-                         struct amifb_par *par)
+static int amifb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
+                          u_int transp, struct fb_info *info)
 {
-       u_short clk_shift, line_shift;
-       u_long maxfetchstop, fstrt, fsize, fconst, xres_n, yres_n;
-       u_int htotal, vtotal;
+       if (IS_AGA) {
+               if (regno > 255)
+                       return 1;
+       } else if (currentpar.bplcon0 & BPC0_SHRES) {
+               if (regno > 3)
+                       return 1;
+       } else {
+               if (regno > 31)
+                       return 1;
+       }
+       red >>= 8;
+       green >>= 8;
+       blue >>= 8;
+       if (!regno) {
+               red0 = red;
+               green0 = green;
+               blue0 = blue;
+       }
 
        /*
-        * Find a matching Pixel Clock
+        * Update the corresponding Hardware Color Register, unless it's Color
+        * Register 0 and the screen is blanked.
+        *
+        * VBlank is switched off to protect bplcon3 or ecs_palette[] from
+        * being changed by ami_do_blank() during the VBlank.
         */
 
-       for (clk_shift = TAG_SHRES; clk_shift <= TAG_LORES; clk_shift++)
-               if (var->pixclock <= pixclock[clk_shift])
-                       break;
-       if (clk_shift > TAG_LORES) {
-               DPRINTK("pixclock too high\n");
-               return -EINVAL;
+       if (regno || !is_blanked) {
+#if defined(CONFIG_FB_AMIGA_AGA)
+               if (IS_AGA) {
+                       u_short bplcon3 = currentpar.bplcon3;
+                       VBlankOff();
+                       custom.bplcon3 = bplcon3 | (regno << 8 & 0xe000);
+                       custom.color[regno & 31] = rgb2hw8_high(red, green,
+                                                               blue);
+                       custom.bplcon3 = bplcon3 | (regno << 8 & 0xe000) |
+                                        BPC3_LOCT;
+                       custom.color[regno & 31] = rgb2hw8_low(red, green,
+                                                              blue);
+                       custom.bplcon3 = bplcon3;
+                       VBlankOn();
+               } else
+#endif
+#if defined(CONFIG_FB_AMIGA_ECS)
+               if (currentpar.bplcon0 & BPC0_SHRES) {
+                       u_short color, mask;
+                       int i;
+
+                       mask = 0x3333;
+                       color = rgb2hw2(red, green, blue);
+                       VBlankOff();
+                       for (i = regno + 12; i >= (int)regno; i -= 4)
+                               custom.color[i] = ecs_palette[i] = (ecs_palette[i] & mask) | color;
+                       mask <<= 2; color >>= 2;
+                       regno = down16(regno) + mul4(mod4(regno));
+                       for (i = regno + 3; i >= (int)regno; i--)
+                               custom.color[i] = ecs_palette[i] = (ecs_palette[i] & mask) | color;
+                       VBlankOn();
+               } else
+#endif
+                       custom.color[regno] = rgb2hw4(red, green, blue);
        }
-       par->clk_shift = clk_shift;
+       return 0;
+}
+
 
        /*
-        * Check the Geometry Values
+        * Blank the display.
         */
 
-       if ((par->xres = var->xres) < 64)
-               par->xres = 64;
-       if ((par->yres = var->yres) < 64)
-               par->yres = 64;
-       if ((par->vxres = var->xres_virtual) < par->xres)
-               par->vxres = par->xres;
-       if ((par->vyres = var->yres_virtual) < par->yres)
-               par->vyres = par->yres;
+static int amifb_blank(int blank, struct fb_info *info)
+{
+       do_blank = blank ? blank : -1;
 
-       par->bpp = var->bits_per_pixel;
-       if (!var->nonstd) {
-               if (par->bpp < 1)
-                       par->bpp = 1;
-               if (par->bpp > maxdepth[clk_shift]) {
-                       if (round_down_bpp && maxdepth[clk_shift])
-                               par->bpp = maxdepth[clk_shift];
-                       else {
-                               DPRINTK("invalid bpp\n");
-                               return -EINVAL;
-                       }
-               }
-       } else if (var->nonstd == FB_NONSTD_HAM) {
-               if (par->bpp < 6)
-                       par->bpp = 6;
-               if (par->bpp != 6) {
-                       if (par->bpp < 8)
-                               par->bpp = 8;
-                       if (par->bpp != 8 || !IS_AGA) {
-                               DPRINTK("invalid bpp for ham mode\n");
+       return 0;
+}
+
+
+       /*
+        * Pan or Wrap the Display
+        *
+        * This call looks only at xoffset, yoffset and the FB_VMODE_YWRAP flag
+        */
+
+static int amifb_pan_display(struct fb_var_screeninfo *var,
+                            struct fb_info *info)
+{
+       if (var->vmode & FB_VMODE_YWRAP) {
+               if (var->yoffset < 0 ||
+                       var->yoffset >= info->var.yres_virtual || var->xoffset)
                                return -EINVAL;
-                       }
-               }
        } else {
-               DPRINTK("unknown nonstd mode\n");
-               return -EINVAL;
+               /*
+                * TODO: There will be problems when xpan!=1, so some columns
+                * on the right side will never be seen
+                */
+               if (var->xoffset + info->var.xres >
+                   upx(16 << maxfmode, info->var.xres_virtual) ||
+                   var->yoffset + info->var.yres > info->var.yres_virtual)
+                       return -EINVAL;
        }
+       ami_pan_var(var);
+       info->var.xoffset = var->xoffset;
+       info->var.yoffset = var->yoffset;
+       if (var->vmode & FB_VMODE_YWRAP)
+               info->var.vmode |= FB_VMODE_YWRAP;
+       else
+               info->var.vmode &= ~FB_VMODE_YWRAP;
+       return 0;
+}
+
+
+#if BITS_PER_LONG == 32
+#define BYTES_PER_LONG 4
+#define SHIFT_PER_LONG 5
+#elif BITS_PER_LONG == 64
+#define BYTES_PER_LONG 8
+#define SHIFT_PER_LONG 6
+#else
+#define Please update me
+#endif
+
 
        /*
-        * FB_VMODE_SMOOTH_XPAN will be cleared, if one of the folloing
-        * checks failed and smooth scrolling is not possible
+        *  Compose two values, using a bitmask as decision value
+        *  This is equivalent to (a & mask) | (b & ~mask)
         */
 
-       par->vmode = var->vmode | FB_VMODE_SMOOTH_XPAN;
-       switch (par->vmode & FB_VMODE_MASK) {
-       case FB_VMODE_INTERLACED:
-               line_shift = 0;
-               break;
-       case FB_VMODE_NONINTERLACED:
-               line_shift = 1;
-               break;
-       case FB_VMODE_DOUBLE:
-               if (!IS_AGA) {
-                       DPRINTK("double mode only possible with aga\n");
-                       return -EINVAL;
-               }
-               line_shift = 2;
-               break;
-       default:
-               DPRINTK("unknown video mode\n");
-               return -EINVAL;
-               break;
-       }
-       par->line_shift = line_shift;
+static inline unsigned long comp(unsigned long a, unsigned long b,
+                                unsigned long mask)
+{
+       return ((a ^ b) & mask) ^ b;
+}
+
+
+static inline unsigned long xor(unsigned long a, unsigned long b,
+                               unsigned long mask)
+{
+       return (a & mask) ^ b;
+}
+
 
        /*
-        * Vertical and Horizontal Timings
+        *  Unaligned forward bit copy using 32-bit or 64-bit memory accesses
         */
 
-       xres_n = par->xres << clk_shift;
-       yres_n = par->yres << line_shift;
-       par->htotal = down8((var->left_margin + par->xres + var->right_margin +
-                            var->hsync_len) << clk_shift);
-       par->vtotal =
-               down2(((var->upper_margin + par->yres + var->lower_margin +
-                       var->vsync_len) << line_shift) + 1);
+static void bitcpy(unsigned long *dst, int dst_idx, const unsigned long *src,
+                  int src_idx, u32 n)
+{
+       unsigned long first, last;
+       int shift = dst_idx - src_idx, left, right;
+       unsigned long d0, d1;
+       int m;
 
-       if (IS_AGA)
-               par->bplcon3 = sprpixmode[clk_shift];
-       else
-               par->bplcon3 = 0;
-       if (var->sync & FB_SYNC_BROADCAST) {
-               par->diwstop_h = par->htotal -
-                       ((var->right_margin - var->hsync_len) << clk_shift);
-               if (IS_AGA)
-                       par->diwstop_h += mod4(var->hsync_len);
-               else
-                       par->diwstop_h = down4(par->diwstop_h);
+       if (!n)
+               return;
 
-               par->diwstrt_h = par->diwstop_h - xres_n;
-               par->diwstop_v = par->vtotal -
-                       ((var->lower_margin - var->vsync_len) << line_shift);
-               par->diwstrt_v = par->diwstop_v - yres_n;
-               if (par->diwstop_h >= par->htotal + 8) {
-                       DPRINTK("invalid diwstop_h\n");
-                       return -EINVAL;
-               }
-               if (par->diwstop_v > par->vtotal) {
-                       DPRINTK("invalid diwstop_v\n");
-                       return -EINVAL;
-               }
+       shift = dst_idx - src_idx;
+       first = ~0UL >> dst_idx;
+       last = ~(~0UL >> ((dst_idx + n) % BITS_PER_LONG));
 
-               if (!IS_OCS) {
-                       /* Initialize sync with some reasonable values for pwrsave */
-                       par->hsstrt = 160;
-                       par->hsstop = 320;
-                       par->vsstrt = 30;
-                       par->vsstop = 34;
+       if (!shift) {
+               // Same alignment for source and dest
+
+               if (dst_idx + n <= BITS_PER_LONG) {
+                       // Single word
+                       if (last)
+                               first &= last;
+                       *dst = comp(*src, *dst, first);
                } else {
-                       par->hsstrt = 0;
-                       par->hsstop = 0;
-                       par->vsstrt = 0;
-                       par->vsstop = 0;
-               }
-               if (par->vtotal > (PAL_VTOTAL + NTSC_VTOTAL) / 2) {
-                       /* PAL video mode */
-                       if (par->htotal != PAL_HTOTAL) {
-                               DPRINTK("htotal invalid for pal\n");
-                               return -EINVAL;
-                       }
-                       if (par->diwstrt_h < PAL_DIWSTRT_H) {
-                               DPRINTK("diwstrt_h too low for pal\n");
-                               return -EINVAL;
+                       // Multiple destination words
+                       // Leading bits
+                       if (first) {
+                               *dst = comp(*src, *dst, first);
+                               dst++;
+                               src++;
+                               n -= BITS_PER_LONG - dst_idx;
                        }
-                       if (par->diwstrt_v < PAL_DIWSTRT_V) {
-                               DPRINTK("diwstrt_v too low for pal\n");
-                               return -EINVAL;
+
+                       // Main chunk
+                       n /= BITS_PER_LONG;
+                       while (n >= 8) {
+                               *dst++ = *src++;
+                               *dst++ = *src++;
+                               *dst++ = *src++;
+                               *dst++ = *src++;
+                               *dst++ = *src++;
+                               *dst++ = *src++;
+                               *dst++ = *src++;
+                               *dst++ = *src++;
+                               n -= 8;
                        }
-                       htotal = PAL_HTOTAL>>clk_shift;
-                       vtotal = PAL_VTOTAL>>1;
-                       if (!IS_OCS) {
-                               par->beamcon0 = BMC0_PAL;
-                               par->bplcon3 |= BPC3_BRDRBLNK;
-                       } else if (AMIGAHW_PRESENT(AGNUS_HR_PAL) ||
-                                  AMIGAHW_PRESENT(AGNUS_HR_NTSC)) {
-                               par->beamcon0 = BMC0_PAL;
-                               par->hsstop = 1;
-                       } else if (amiga_vblank != 50) {
-                               DPRINTK("pal not supported by this chipset\n");
-                               return -EINVAL;
+                       while (n--)
+                               *dst++ = *src++;
+
+                       // Trailing bits
+                       if (last)
+                               *dst = comp(*src, *dst, last);
+               }
+       } else {
+               // Different alignment for source and dest
+
+               right = shift & (BITS_PER_LONG - 1);
+               left = -shift & (BITS_PER_LONG - 1);
+
+               if (dst_idx + n <= BITS_PER_LONG) {
+                       // Single destination word
+                       if (last)
+                               first &= last;
+                       if (shift > 0) {
+                               // Single source word
+                               *dst = comp(*src >> right, *dst, first);
+                       } else if (src_idx + n <= BITS_PER_LONG) {
+                               // Single source word
+                               *dst = comp(*src << left, *dst, first);
+                       } else {
+                               // 2 source words
+                               d0 = *src++;
+                               d1 = *src;
+                               *dst = comp(d0 << left | d1 >> right, *dst,
+                                           first);
                        }
                } else {
-                       /* NTSC video mode
-                        * In the AGA chipset seems to be hardware bug with BPC3_BRDRBLNK
-                        * and NTSC activated, so than better let diwstop_h <= 1812
-                        */
-                       if (par->htotal != NTSC_HTOTAL) {
-                               DPRINTK("htotal invalid for ntsc\n");
-                               return -EINVAL;
-                       }
-                       if (par->diwstrt_h < NTSC_DIWSTRT_H) {
-                               DPRINTK("diwstrt_h too low for ntsc\n");
-                               return -EINVAL;
+                       // Multiple destination words
+                       d0 = *src++;
+                       // Leading bits
+                       if (shift > 0) {
+                               // Single source word
+                               *dst = comp(d0 >> right, *dst, first);
+                               dst++;
+                               n -= BITS_PER_LONG - dst_idx;
+                       } else {
+                               // 2 source words
+                               d1 = *src++;
+                               *dst = comp(d0 << left | d1 >> right, *dst,
+                                           first);
+                               d0 = d1;
+                               dst++;
+                               n -= BITS_PER_LONG - dst_idx;
                        }
-                       if (par->diwstrt_v < NTSC_DIWSTRT_V) {
-                               DPRINTK("diwstrt_v too low for ntsc\n");
-                               return -EINVAL;
+
+                       // Main chunk
+                       m = n % BITS_PER_LONG;
+                       n /= BITS_PER_LONG;
+                       while (n >= 4) {
+                               d1 = *src++;
+                               *dst++ = d0 << left | d1 >> right;
+                               d0 = d1;
+                               d1 = *src++;
+                               *dst++ = d0 << left | d1 >> right;
+                               d0 = d1;
+                               d1 = *src++;
+                               *dst++ = d0 << left | d1 >> right;
+                               d0 = d1;
+                               d1 = *src++;
+                               *dst++ = d0 << left | d1 >> right;
+                               d0 = d1;
+                               n -= 4;
                        }
-                       htotal = NTSC_HTOTAL>>clk_shift;
-                       vtotal = NTSC_VTOTAL>>1;
-                       if (!IS_OCS) {
-                               par->beamcon0 = 0;
-                               par->bplcon3 |= BPC3_BRDRBLNK;
-                       } else if (AMIGAHW_PRESENT(AGNUS_HR_PAL) ||
-                                  AMIGAHW_PRESENT(AGNUS_HR_NTSC)) {
-                               par->beamcon0 = 0;
-                               par->hsstop = 1;
-                       } else if (amiga_vblank != 60) {
-                               DPRINTK("ntsc not supported by this chipset\n");
-                               return -EINVAL;
+                       while (n--) {
+                               d1 = *src++;
+                               *dst++ = d0 << left | d1 >> right;
+                               d0 = d1;
                        }
-               }
-               if (IS_OCS) {
-                       if (par->diwstrt_h >= 1024 || par->diwstop_h < 1024 ||
-                           par->diwstrt_v >=  512 || par->diwstop_v <  256) {
-                               DPRINTK("invalid position for display on ocs\n");
-                               return -EINVAL;
+
+                       // Trailing bits
+                       if (last) {
+                               if (m <= right) {
+                                       // Single source word
+                                       *dst = comp(d0 << left, *dst, last);
+                               } else {
+                                       // 2 source words
+                                       d1 = *src;
+                                       *dst = comp(d0 << left | d1 >> right,
+                                                   *dst, last);
+                               }
                        }
                }
-       } else if (!IS_OCS) {
-               /* Programmable video mode */
-               par->hsstrt = var->right_margin << clk_shift;
-               par->hsstop = (var->right_margin + var->hsync_len) << clk_shift;
-               par->diwstop_h = par->htotal - mod8(par->hsstrt) + 8 - (1 << clk_shift);
-               if (!IS_AGA)
-                       par->diwstop_h = down4(par->diwstop_h) - 16;
-               par->diwstrt_h = par->diwstop_h - xres_n;
-               par->hbstop = par->diwstrt_h + 4;
-               par->hbstrt = par->diwstop_h + 4;
-               if (par->hbstrt >= par->htotal + 8)
-                       par->hbstrt -= par->htotal;
-               par->hcenter = par->hsstrt + (par->htotal >> 1);
-               par->vsstrt = var->lower_margin << line_shift;
-               par->vsstop = (var->lower_margin + var->vsync_len) << line_shift;
-               par->diwstop_v = par->vtotal;
-               if ((par->vmode & FB_VMODE_MASK) == FB_VMODE_INTERLACED)
-                       par->diwstop_v -= 2;
-               par->diwstrt_v = par->diwstop_v - yres_n;
-               par->vbstop = par->diwstrt_v - 2;
-               par->vbstrt = par->diwstop_v - 2;
-               if (par->vtotal > 2048) {
-                       DPRINTK("vtotal too high\n");
-                       return -EINVAL;
-               }
-               if (par->htotal > 2048) {
-                       DPRINTK("htotal too high\n");
-                       return -EINVAL;
-               }
-               par->bplcon3 |= BPC3_EXTBLKEN;
-               par->beamcon0 = BMC0_HARDDIS | BMC0_VARVBEN | BMC0_LOLDIS |
-                               BMC0_VARVSYEN | BMC0_VARHSYEN | BMC0_VARBEAMEN |
-                               BMC0_PAL | BMC0_VARCSYEN;
-               if (var->sync & FB_SYNC_HOR_HIGH_ACT)
-                       par->beamcon0 |= BMC0_HSYTRUE;
-               if (var->sync & FB_SYNC_VERT_HIGH_ACT)
-                       par->beamcon0 |= BMC0_VSYTRUE;
-               if (var->sync & FB_SYNC_COMP_HIGH_ACT)
-                       par->beamcon0 |= BMC0_CSYTRUE;
-               htotal = par->htotal>>clk_shift;
-               vtotal = par->vtotal>>1;
-       } else {
-               DPRINTK("only broadcast modes possible for ocs\n");
-               return -EINVAL;
        }
+}
 
-       /*
-        * Checking the DMA timing
-        */
-
-       fconst = 16 << maxfmode << clk_shift;
 
        /*
-        * smallest window start value without turn off other dma cycles
-        * than sprite1-7, unless you change min_fstrt
+        *  Unaligned reverse bit copy using 32-bit or 64-bit memory accesses
         */
 
+static void bitcpy_rev(unsigned long *dst, int dst_idx,
+                      const unsigned long *src, int src_idx, u32 n)
+{
+       unsigned long first, last;
+       int shift = dst_idx - src_idx, left, right;
+       unsigned long d0, d1;
+       int m;
+
+       if (!n)
+               return;
 
-       fsize = ((maxfmode + clk_shift <= 1) ? fconst : 64);
-       fstrt = downx(fconst, par->diwstrt_h - 4) - fsize;
-       if (fstrt < min_fstrt) {
-               DPRINTK("fetch start too low\n");
-               return -EINVAL;
+       dst += (n - 1) / BITS_PER_LONG;
+       src += (n - 1) / BITS_PER_LONG;
+       if ((n - 1) % BITS_PER_LONG) {
+               dst_idx += (n - 1) % BITS_PER_LONG;
+               dst += dst_idx >> SHIFT_PER_LONG;
+               dst_idx &= BITS_PER_LONG - 1;
+               src_idx += (n - 1) % BITS_PER_LONG;
+               src += src_idx >> SHIFT_PER_LONG;
+               src_idx &= BITS_PER_LONG - 1;
        }
 
-       /*
-        * smallest window start value where smooth scrolling is possible
-        */
-
-       fstrt = downx(fconst, par->diwstrt_h - fconst + (1 << clk_shift) - 4) -
-               fsize;
-       if (fstrt < min_fstrt)
-               par->vmode &= ~FB_VMODE_SMOOTH_XPAN;
+       shift = dst_idx - src_idx;
+       first = ~0UL << (BITS_PER_LONG - 1 - dst_idx);
+       last = ~(~0UL << (BITS_PER_LONG - 1 - ((dst_idx - n) % BITS_PER_LONG)));
 
-       maxfetchstop = down16(par->htotal - 80);
-
-       fstrt = downx(fconst, par->diwstrt_h - 4) - 64 - fconst;
-       fsize = upx(fconst, xres_n +
-                   modx(fconst, downx(1 << clk_shift, par->diwstrt_h - 4)));
-       if (fstrt + fsize > maxfetchstop)
-               par->vmode &= ~FB_VMODE_SMOOTH_XPAN;
+       if (!shift) {
+               // Same alignment for source and dest
 
-       fsize = upx(fconst, xres_n);
-       if (fstrt + fsize > maxfetchstop) {
-               DPRINTK("fetch stop too high\n");
-               return -EINVAL;
-       }
+               if ((unsigned long)dst_idx + 1 >= n) {
+                       // Single word
+                       if (last)
+                               first &= last;
+                       *dst = comp(*src, *dst, first);
+               } else {
+                       // Multiple destination words
+                       // Leading bits
+                       if (first) {
+                               *dst = comp(*src, *dst, first);
+                               dst--;
+                               src--;
+                               n -= dst_idx + 1;
+                       }
 
-       if (maxfmode + clk_shift <= 1) {
-               fsize = up64(xres_n + fconst - 1);
-               if (min_fstrt + fsize - 64 > maxfetchstop)
-                       par->vmode &= ~FB_VMODE_SMOOTH_XPAN;
+                       // Main chunk
+                       n /= BITS_PER_LONG;
+                       while (n >= 8) {
+                               *dst-- = *src--;
+                               *dst-- = *src--;
+                               *dst-- = *src--;
+                               *dst-- = *src--;
+                               *dst-- = *src--;
+                               *dst-- = *src--;
+                               *dst-- = *src--;
+                               *dst-- = *src--;
+                               n -= 8;
+                       }
+                       while (n--)
+                               *dst-- = *src--;
 
-               fsize = up64(xres_n);
-               if (min_fstrt + fsize - 64 > maxfetchstop) {
-                       DPRINTK("fetch size too high\n");
-                       return -EINVAL;
+                       // Trailing bits
+                       if (last)
+                               *dst = comp(*src, *dst, last);
                }
+       } else {
+               // Different alignment for source and dest
 
-               fsize -= 64;
-       } else
-               fsize -= fconst;
-
-       /*
-        * Check if there is enough time to update the bitplane pointers for ywrap
-        */
+               right = shift & (BITS_PER_LONG - 1);
+               left = -shift & (BITS_PER_LONG - 1);
 
-       if (par->htotal - fsize - 64 < par->bpp * 64)
-               par->vmode &= ~FB_VMODE_YWRAP;
+               if ((unsigned long)dst_idx + 1 >= n) {
+                       // Single destination word
+                       if (last)
+                               first &= last;
+                       if (shift < 0) {
+                               // Single source word
+                               *dst = comp(*src << left, *dst, first);
+                       } else if (1 + (unsigned long)src_idx >= n) {
+                               // Single source word
+                               *dst = comp(*src >> right, *dst, first);
+                       } else {
+                               // 2 source words
+                               d0 = *src--;
+                               d1 = *src;
+                               *dst = comp(d0 >> right | d1 << left, *dst,
+                                           first);
+                       }
+               } else {
+                       // Multiple destination words
+                       d0 = *src--;
+                       // Leading bits
+                       if (shift < 0) {
+                               // Single source word
+                               *dst = comp(d0 << left, *dst, first);
+                               dst--;
+                               n -= dst_idx + 1;
+                       } else {
+                               // 2 source words
+                               d1 = *src--;
+                               *dst = comp(d0 >> right | d1 << left, *dst,
+                                           first);
+                               d0 = d1;
+                               dst--;
+                               n -= dst_idx + 1;
+                       }
 
-       /*
-        * Bitplane calculations and check the Memory Requirements
-        */
+                       // Main chunk
+                       m = n % BITS_PER_LONG;
+                       n /= BITS_PER_LONG;
+                       while (n >= 4) {
+                               d1 = *src--;
+                               *dst-- = d0 >> right | d1 << left;
+                               d0 = d1;
+                               d1 = *src--;
+                               *dst-- = d0 >> right | d1 << left;
+                               d0 = d1;
+                               d1 = *src--;
+                               *dst-- = d0 >> right | d1 << left;
+                               d0 = d1;
+                               d1 = *src--;
+                               *dst-- = d0 >> right | d1 << left;
+                               d0 = d1;
+                               n -= 4;
+                       }
+                       while (n--) {
+                               d1 = *src--;
+                               *dst-- = d0 >> right | d1 << left;
+                               d0 = d1;
+                       }
 
-       if (amifb_ilbm) {
-               par->next_plane = div8(upx(16 << maxfmode, par->vxres));
-               par->next_line = par->bpp * par->next_plane;
-               if (par->next_line * par->vyres > fb_info.fix.smem_len) {
-                       DPRINTK("too few video mem\n");
-                       return -EINVAL;
-               }
-       } else {
-               par->next_line = div8(upx(16 << maxfmode, par->vxres));
-               par->next_plane = par->vyres * par->next_line;
-               if (par->next_plane * par->bpp > fb_info.fix.smem_len) {
-                       DPRINTK("too few video mem\n");
-                       return -EINVAL;
+                       // Trailing bits
+                       if (last) {
+                               if (m <= left) {
+                                       // Single source word
+                                       *dst = comp(d0 >> right, *dst, last);
+                               } else {
+                                       // 2 source words
+                                       d1 = *src;
+                                       *dst = comp(d0 >> right | d1 << left,
+                                                   *dst, last);
+                               }
+                       }
                }
        }
+}
+
 
        /*
-        * Hardware Register Values
+        *  Unaligned forward inverting bit copy using 32-bit or 64-bit memory
+        *  accesses
         */
 
-       par->bplcon0 = BPC0_COLOR | bplpixmode[clk_shift];
-       if (!IS_OCS)
-               par->bplcon0 |= BPC0_ECSENA;
-       if (par->bpp == 8)
-               par->bplcon0 |= BPC0_BPU3;
-       else
-               par->bplcon0 |= par->bpp << 12;
-       if (var->nonstd == FB_NONSTD_HAM)
-               par->bplcon0 |= BPC0_HAM;
-       if (var->sync & FB_SYNC_EXT)
-               par->bplcon0 |= BPC0_ERSY;
+static void bitcpy_not(unsigned long *dst, int dst_idx,
+                      const unsigned long *src, int src_idx, u32 n)
+{
+       unsigned long first, last;
+       int shift = dst_idx - src_idx, left, right;
+       unsigned long d0, d1;
+       int m;
 
-       if (IS_AGA)
-               par->fmode = bplfetchmode[maxfmode];
+       if (!n)
+               return;
 
-       switch (par->vmode & FB_VMODE_MASK) {
-       case FB_VMODE_INTERLACED:
-               par->bplcon0 |= BPC0_LACE;
-               break;
-       case FB_VMODE_DOUBLE:
-               if (IS_AGA)
-                       par->fmode |= FMODE_SSCAN2 | FMODE_BSCAN2;
-               break;
-       }
+       shift = dst_idx - src_idx;
+       first = ~0UL >> dst_idx;
+       last = ~(~0UL >> ((dst_idx + n) % BITS_PER_LONG));
 
-       if (!((par->vmode ^ var->vmode) & FB_VMODE_YWRAP)) {
-               par->xoffset = var->xoffset;
-               par->yoffset = var->yoffset;
-               if (par->vmode & FB_VMODE_YWRAP) {
-                       if (par->xoffset || par->yoffset < 0 ||
-                           par->yoffset >= par->vyres)
-                               par->xoffset = par->yoffset = 0;
+       if (!shift) {
+               // Same alignment for source and dest
+
+               if (dst_idx + n <= BITS_PER_LONG) {
+                       // Single word
+                       if (last)
+                               first &= last;
+                       *dst = comp(~*src, *dst, first);
                } else {
-                       if (par->xoffset < 0 ||
-                           par->xoffset > upx(16 << maxfmode, par->vxres - par->xres) ||
-                           par->yoffset < 0 || par->yoffset > par->vyres - par->yres)
-                               par->xoffset = par->yoffset = 0;
-               }
-       } else
-               par->xoffset = par->yoffset = 0;
+                       // Multiple destination words
+                       // Leading bits
+                       if (first) {
+                               *dst = comp(~*src, *dst, first);
+                               dst++;
+                               src++;
+                               n -= BITS_PER_LONG - dst_idx;
+                       }
 
-       par->crsr.crsr_x = par->crsr.crsr_y = 0;
-       par->crsr.spot_x = par->crsr.spot_y = 0;
-       par->crsr.height = par->crsr.width = 0;
+                       // Main chunk
+                       n /= BITS_PER_LONG;
+                       while (n >= 8) {
+                               *dst++ = ~*src++;
+                               *dst++ = ~*src++;
+                               *dst++ = ~*src++;
+                               *dst++ = ~*src++;
+                               *dst++ = ~*src++;
+                               *dst++ = ~*src++;
+                               *dst++ = ~*src++;
+                               *dst++ = ~*src++;
+                               n -= 8;
+                       }
+                       while (n--)
+                               *dst++ = ~*src++;
 
-       return 0;
-}
+                       // Trailing bits
+                       if (last)
+                               *dst = comp(~*src, *dst, last);
+               }
+       } else {
+               // Different alignment for source and dest
 
-       /*
-        * Fill the `var' structure based on the values in `par' and maybe
-        * other values read out of the hardware.
-        */
+               right = shift & (BITS_PER_LONG - 1);
+               left = -shift & (BITS_PER_LONG - 1);
 
-static int ami_encode_var(struct fb_var_screeninfo *var,
-                         struct amifb_par *par)
-{
-       u_short clk_shift, line_shift;
-
-       memset(var, 0, sizeof(struct fb_var_screeninfo));
+               if (dst_idx + n <= BITS_PER_LONG) {
+                       // Single destination word
+                       if (last)
+                               first &= last;
+                       if (shift > 0) {
+                               // Single source word
+                               *dst = comp(~*src >> right, *dst, first);
+                       } else if (src_idx + n <= BITS_PER_LONG) {
+                               // Single source word
+                               *dst = comp(~*src << left, *dst, first);
+                       } else {
+                               // 2 source words
+                               d0 = ~*src++;
+                               d1 = ~*src;
+                               *dst = comp(d0 << left | d1 >> right, *dst,
+                                           first);
+                       }
+               } else {
+                       // Multiple destination words
+                       d0 = ~*src++;
+                       // Leading bits
+                       if (shift > 0) {
+                               // Single source word
+                               *dst = comp(d0 >> right, *dst, first);
+                               dst++;
+                               n -= BITS_PER_LONG - dst_idx;
+                       } else {
+                               // 2 source words
+                               d1 = ~*src++;
+                               *dst = comp(d0 << left | d1 >> right, *dst,
+                                           first);
+                               d0 = d1;
+                               dst++;
+                               n -= BITS_PER_LONG - dst_idx;
+                       }
 
-       clk_shift = par->clk_shift;
-       line_shift = par->line_shift;
+                       // Main chunk
+                       m = n % BITS_PER_LONG;
+                       n /= BITS_PER_LONG;
+                       while (n >= 4) {
+                               d1 = ~*src++;
+                               *dst++ = d0 << left | d1 >> right;
+                               d0 = d1;
+                               d1 = ~*src++;
+                               *dst++ = d0 << left | d1 >> right;
+                               d0 = d1;
+                               d1 = ~*src++;
+                               *dst++ = d0 << left | d1 >> right;
+                               d0 = d1;
+                               d1 = ~*src++;
+                               *dst++ = d0 << left | d1 >> right;
+                               d0 = d1;
+                               n -= 4;
+                       }
+                       while (n--) {
+                               d1 = ~*src++;
+                               *dst++ = d0 << left | d1 >> right;
+                               d0 = d1;
+                       }
 
-       var->xres = par->xres;
-       var->yres = par->yres;
-       var->xres_virtual = par->vxres;
-       var->yres_virtual = par->vyres;
-       var->xoffset = par->xoffset;
-       var->yoffset = par->yoffset;
+                       // Trailing bits
+                       if (last) {
+                               if (m <= right) {
+                                       // Single source word
+                                       *dst = comp(d0 << left, *dst, last);
+                               } else {
+                                       // 2 source words
+                                       d1 = ~*src;
+                                       *dst = comp(d0 << left | d1 >> right,
+                                                   *dst, last);
+                               }
+                       }
+               }
+       }
+}
 
-       var->bits_per_pixel = par->bpp;
-       var->grayscale = 0;
 
-       var->red.offset = 0;
-       var->red.msb_right = 0;
-       var->red.length = par->bpp;
-       if (par->bplcon0 & BPC0_HAM)
-               var->red.length -= 2;
-       var->blue = var->green = var->red;
-       var->transp.offset = 0;
-       var->transp.length = 0;
-       var->transp.msb_right = 0;
+       /*
+        *  Unaligned 32-bit pattern fill using 32/64-bit memory accesses
+        */
 
-       if (par->bplcon0 & BPC0_HAM)
-               var->nonstd = FB_NONSTD_HAM;
-       else
-               var->nonstd = 0;
-       var->activate = 0;
+static void bitfill32(unsigned long *dst, int dst_idx, u32 pat, u32 n)
+{
+       unsigned long val = pat;
+       unsigned long first, last;
 
-       var->height = -1;
-       var->width = -1;
+       if (!n)
+               return;
 
-       var->pixclock = pixclock[clk_shift];
+#if BITS_PER_LONG == 64
+       val |= val << 32;
+#endif
 
-       if (IS_AGA && par->fmode & FMODE_BSCAN2)
-               var->vmode = FB_VMODE_DOUBLE;
-       else if (par->bplcon0 & BPC0_LACE)
-               var->vmode = FB_VMODE_INTERLACED;
-       else
-               var->vmode = FB_VMODE_NONINTERLACED;
+       first = ~0UL >> dst_idx;
+       last = ~(~0UL >> ((dst_idx + n) % BITS_PER_LONG));
 
-       if (!IS_OCS && par->beamcon0 & BMC0_VARBEAMEN) {
-               var->hsync_len = (par->hsstop - par->hsstrt)>>clk_shift;
-               var->right_margin = par->hsstrt>>clk_shift;
-               var->left_margin = (par->htotal>>clk_shift) - var->xres - var->right_margin - var->hsync_len;
-               var->vsync_len = (par->vsstop - par->vsstrt)>>line_shift;
-               var->lower_margin = par->vsstrt>>line_shift;
-               var->upper_margin = (par->vtotal>>line_shift) - var->yres - var->lower_margin - var->vsync_len;
-               var->sync = 0;
-               if (par->beamcon0 & BMC0_HSYTRUE)
-                       var->sync |= FB_SYNC_HOR_HIGH_ACT;
-               if (par->beamcon0 & BMC0_VSYTRUE)
-                       var->sync |= FB_SYNC_VERT_HIGH_ACT;
-               if (par->beamcon0 & BMC0_CSYTRUE)
-                       var->sync |= FB_SYNC_COMP_HIGH_ACT;
+       if (dst_idx + n <= BITS_PER_LONG) {
+               // Single word
+               if (last)
+                       first &= last;
+               *dst = comp(val, *dst, first);
        } else {
-               var->sync = FB_SYNC_BROADCAST;
-               var->hsync_len = (152>>clk_shift) + mod4(par->diwstop_h);
-               var->right_margin = ((par->htotal - down4(par->diwstop_h))>>clk_shift) + var->hsync_len;
-               var->left_margin = (par->htotal>>clk_shift) - var->xres - var->right_margin - var->hsync_len;
-               var->vsync_len = 4>>line_shift;
-               var->lower_margin = ((par->vtotal - par->diwstop_v)>>line_shift) + var->vsync_len;
-               var->upper_margin = (((par->vtotal - 2)>>line_shift) + 1) - var->yres -
-                                   var->lower_margin - var->vsync_len;
-       }
+               // Multiple destination words
+               // Leading bits
+               if (first) {
+                       *dst = comp(val, *dst, first);
+                       dst++;
+                       n -= BITS_PER_LONG - dst_idx;
+               }
 
-       if (par->bplcon0 & BPC0_ERSY)
-               var->sync |= FB_SYNC_EXT;
-       if (par->vmode & FB_VMODE_YWRAP)
-               var->vmode |= FB_VMODE_YWRAP;
+               // Main chunk
+               n /= BITS_PER_LONG;
+               while (n >= 8) {
+                       *dst++ = val;
+                       *dst++ = val;
+                       *dst++ = val;
+                       *dst++ = val;
+                       *dst++ = val;
+                       *dst++ = val;
+                       *dst++ = val;
+                       *dst++ = val;
+                       n -= 8;
+               }
+               while (n--)
+                       *dst++ = val;
 
-       return 0;
+               // Trailing bits
+               if (last)
+                       *dst = comp(val, *dst, last);
+       }
 }
 
 
        /*
-        * Pan or Wrap the Display
-        *
-        * This call looks only at xoffset, yoffset and the FB_VMODE_YWRAP flag
-        * in `var'.
+        *  Unaligned 32-bit pattern xor using 32/64-bit memory accesses
         */
 
-static void ami_pan_var(struct fb_var_screeninfo *var)
+static void bitxor32(unsigned long *dst, int dst_idx, u32 pat, u32 n)
 {
-       struct amifb_par *par = &currentpar;
+       unsigned long val = pat;
+       unsigned long first, last;
 
-       par->xoffset = var->xoffset;
-       par->yoffset = var->yoffset;
-       if (var->vmode & FB_VMODE_YWRAP)
-               par->vmode |= FB_VMODE_YWRAP;
-       else
-               par->vmode &= ~FB_VMODE_YWRAP;
+       if (!n)
+               return;
 
-       do_vmode_pan = 0;
-       ami_update_par();
-       do_vmode_pan = 1;
-}
+#if BITS_PER_LONG == 64
+       val |= val << 32;
+#endif
 
-       /*
-        * Update hardware
-        */
+       first = ~0UL >> dst_idx;
+       last = ~(~0UL >> ((dst_idx + n) % BITS_PER_LONG));
 
-static int ami_update_par(void)
-{
-       struct amifb_par *par = &currentpar;
-       short clk_shift, vshift, fstrt, fsize, fstop, fconst,  shift, move, mod;
+       if (dst_idx + n <= BITS_PER_LONG) {
+               // Single word
+               if (last)
+                       first &= last;
+               *dst = xor(val, *dst, first);
+       } else {
+               // Multiple destination words
+               // Leading bits
+               if (first) {
+                       *dst = xor(val, *dst, first);
+                       dst++;
+                       n -= BITS_PER_LONG - dst_idx;
+               }
 
-       clk_shift = par->clk_shift;
+               // Main chunk
+               n /= BITS_PER_LONG;
+               while (n >= 4) {
+                       *dst++ ^= val;
+                       *dst++ ^= val;
+                       *dst++ ^= val;
+                       *dst++ ^= val;
+                       n -= 4;
+               }
+               while (n--)
+                       *dst++ ^= val;
 
-       if (!(par->vmode & FB_VMODE_SMOOTH_XPAN))
-               par->xoffset = upx(16 << maxfmode, par->xoffset);
+               // Trailing bits
+               if (last)
+                       *dst = xor(val, *dst, last);
+       }
+}
 
-       fconst = 16 << maxfmode << clk_shift;
-       vshift = modx(16 << maxfmode, par->xoffset);
-       fstrt = par->diwstrt_h - (vshift << clk_shift) - 4;
-       fsize = (par->xres + vshift) << clk_shift;
-       shift = modx(fconst, fstrt);
-       move = downx(2 << maxfmode, div8(par->xoffset));
-       if (maxfmode + clk_shift > 1) {
-               fstrt = downx(fconst, fstrt) - 64;
-               fsize = upx(fconst, fsize);
-               fstop = fstrt + fsize - fconst;
-       } else {
-               mod = fstrt = downx(fconst, fstrt) - fconst;
-               fstop = fstrt + upx(fconst, fsize) - 64;
-               fsize = up64(fsize);
-               fstrt = fstop - fsize + 64;
-               if (fstrt < min_fstrt) {
-                       fstop += min_fstrt - fstrt;
-                       fstrt = min_fstrt;
-               }
-               move = move - div8((mod - fstrt)>>clk_shift);
+static inline void fill_one_line(int bpp, unsigned long next_plane,
+                                unsigned long *dst, int dst_idx, u32 n,
+                                u32 color)
+{
+       while (1) {
+               dst += dst_idx >> SHIFT_PER_LONG;
+               dst_idx &= (BITS_PER_LONG - 1);
+               bitfill32(dst, dst_idx, color & 1 ? ~0 : 0, n);
+               if (!--bpp)
+                       break;
+               color >>= 1;
+               dst_idx += next_plane * 8;
        }
-       mod = par->next_line - div8(fsize>>clk_shift);
-       par->ddfstrt = fstrt;
-       par->ddfstop = fstop;
-       par->bplcon1 = hscroll2hw(shift);
-       par->bpl2mod = mod;
-       if (par->bplcon0 & BPC0_LACE)
-               par->bpl2mod += par->next_line;
-       if (IS_AGA && (par->fmode & FMODE_BSCAN2))
-               par->bpl1mod = -div8(fsize>>clk_shift);
-       else
-               par->bpl1mod = par->bpl2mod;
-
-       if (par->yoffset) {
-               par->bplpt0 = fb_info.fix.smem_start +
-                             par->next_line * par->yoffset + move;
-               if (par->vmode & FB_VMODE_YWRAP) {
-                       if (par->yoffset > par->vyres - par->yres) {
-                               par->bplpt0wrap = fb_info.fix.smem_start + move;
-                               if (par->bplcon0 & BPC0_LACE &&
-                                   mod2(par->diwstrt_v + par->vyres -
-                                        par->yoffset))
-                                       par->bplpt0wrap += par->next_line;
-                       }
-               }
-       } else
-               par->bplpt0 = fb_info.fix.smem_start + move;
-
-       if (par->bplcon0 & BPC0_LACE && mod2(par->diwstrt_v))
-               par->bplpt0 += par->next_line;
-
-       return 0;
 }
 
+static inline void xor_one_line(int bpp, unsigned long next_plane,
+                               unsigned long *dst, int dst_idx, u32 n,
+                               u32 color)
+{
+       while (color) {
+               dst += dst_idx >> SHIFT_PER_LONG;
+               dst_idx &= (BITS_PER_LONG - 1);
+               bitxor32(dst, dst_idx, color & 1 ? ~0 : 0, n);
+               if (!--bpp)
+                       break;
+               color >>= 1;
+               dst_idx += next_plane * 8;
+       }
+}
 
-       /*
-        * Set a single color register. The values supplied are already
-        * rounded down to the hardware's capabilities (according to the
-        * entries in the var structure). Return != 0 for invalid regno.
-        */
 
-static int amifb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
-                          u_int transp, struct fb_info *info)
+static void amifb_fillrect(struct fb_info *info,
+                          const struct fb_fillrect *rect)
 {
-       if (IS_AGA) {
-               if (regno > 255)
-                       return 1;
-       } else if (currentpar.bplcon0 & BPC0_SHRES) {
-               if (regno > 3)
-                       return 1;
-       } else {
-               if (regno > 31)
-                       return 1;
-       }
-       red >>= 8;
-       green >>= 8;
-       blue >>= 8;
-       if (!regno) {
-               red0 = red;
-               green0 = green;
-               blue0 = blue;
-       }
+       struct amifb_par *par = (struct amifb_par *)info->par;
+       int dst_idx, x2, y2;
+       unsigned long *dst;
+       u32 width, height;
+
+       if (!rect->width || !rect->height)
+               return;
 
        /*
-        * Update the corresponding Hardware Color Register, unless it's Color
-        * Register 0 and the screen is blanked.
-        *
-        * VBlank is switched off to protect bplcon3 or ecs_palette[] from
-        * being changed by ami_do_blank() during the VBlank.
-        */
+        * We could use hardware clipping but on many cards you get around
+        * hardware clipping by writing to framebuffer directly.
+        * */
+       x2 = rect->dx + rect->width;
+       y2 = rect->dy + rect->height;
+       x2 = x2 < info->var.xres_virtual ? x2 : info->var.xres_virtual;
+       y2 = y2 < info->var.yres_virtual ? y2 : info->var.yres_virtual;
+       width = x2 - rect->dx;
+       height = y2 - rect->dy;
 
-       if (regno || !is_blanked) {
-#if defined(CONFIG_FB_AMIGA_AGA)
-               if (IS_AGA) {
-                       u_short bplcon3 = currentpar.bplcon3;
-                       VBlankOff();
-                       custom.bplcon3 = bplcon3 | (regno << 8 & 0xe000);
-                       custom.color[regno & 31] = rgb2hw8_high(red, green,
-                                                               blue);
-                       custom.bplcon3 = bplcon3 | (regno << 8 & 0xe000) |
-                                        BPC3_LOCT;
-                       custom.color[regno & 31] = rgb2hw8_low(red, green,
-                                                              blue);
-                       custom.bplcon3 = bplcon3;
-                       VBlankOn();
-               } else
-#endif
-#if defined(CONFIG_FB_AMIGA_ECS)
-               if (currentpar.bplcon0 & BPC0_SHRES) {
-                       u_short color, mask;
-                       int i;
+       dst = (unsigned long *)
+               ((unsigned long)info->screen_base & ~(BYTES_PER_LONG - 1));
+       dst_idx = ((unsigned long)info->screen_base & (BYTES_PER_LONG - 1)) * 8;
+       dst_idx += rect->dy * par->next_line * 8 + rect->dx;
+       while (height--) {
+               switch (rect->rop) {
+               case ROP_COPY:
+                       fill_one_line(info->var.bits_per_pixel,
+                                     par->next_plane, dst, dst_idx, width,
+                                     rect->color);
+                       break;
 
-                       mask = 0x3333;
-                       color = rgb2hw2(red, green, blue);
-                       VBlankOff();
-                       for (i = regno + 12; i >= (int)regno; i -= 4)
-                               custom.color[i] = ecs_palette[i] = (ecs_palette[i] & mask) | color;
-                       mask <<= 2; color >>= 2;
-                       regno = down16(regno) + mul4(mod4(regno));
-                       for (i = regno + 3; i >= (int)regno; i--)
-                               custom.color[i] = ecs_palette[i] = (ecs_palette[i] & mask) | color;
-                       VBlankOn();
-               } else
-#endif
-                       custom.color[regno] = rgb2hw4(red, green, blue);
+               case ROP_XOR:
+                       xor_one_line(info->var.bits_per_pixel, par->next_plane,
+                                    dst, dst_idx, width, rect->color);
+                       break;
+               }
+               dst_idx += par->next_line * 8;
        }
-       return 0;
 }
 
-static void ami_update_display(void)
+static inline void copy_one_line(int bpp, unsigned long next_plane,
+                                unsigned long *dst, int dst_idx,
+                                unsigned long *src, int src_idx, u32 n)
 {
-       struct amifb_par *par = &currentpar;
-
-       custom.bplcon1 = par->bplcon1;
-       custom.bpl1mod = par->bpl1mod;
-       custom.bpl2mod = par->bpl2mod;
-       custom.ddfstrt = ddfstrt2hw(par->ddfstrt);
-       custom.ddfstop = ddfstop2hw(par->ddfstop);
+       while (1) {
+               dst += dst_idx >> SHIFT_PER_LONG;
+               dst_idx &= (BITS_PER_LONG - 1);
+               src += src_idx >> SHIFT_PER_LONG;
+               src_idx &= (BITS_PER_LONG - 1);
+               bitcpy(dst, dst_idx, src, src_idx, n);
+               if (!--bpp)
+                       break;
+               dst_idx += next_plane * 8;
+               src_idx += next_plane * 8;
+       }
 }
 
-       /*
-        * Change the video mode (called by VBlank interrupt)
-        */
-
-static void ami_init_display(void)
+static inline void copy_one_line_rev(int bpp, unsigned long next_plane,
+                                    unsigned long *dst, int dst_idx,
+                                    unsigned long *src, int src_idx, u32 n)
 {
-       struct amifb_par *par = &currentpar;
-       int i;
-
-       custom.bplcon0 = par->bplcon0 & ~BPC0_LACE;
-       custom.bplcon2 = (IS_OCS ? 0 : BPC2_KILLEHB) | BPC2_PF2P2 | BPC2_PF1P2;
-       if (!IS_OCS) {
-               custom.bplcon3 = par->bplcon3;
-               if (IS_AGA)
-                       custom.bplcon4 = BPC4_ESPRM4 | BPC4_OSPRM4;
-               if (par->beamcon0 & BMC0_VARBEAMEN) {
-                       custom.htotal = htotal2hw(par->htotal);
-                       custom.hbstrt = hbstrt2hw(par->hbstrt);
-                       custom.hbstop = hbstop2hw(par->hbstop);
-                       custom.hsstrt = hsstrt2hw(par->hsstrt);
-                       custom.hsstop = hsstop2hw(par->hsstop);
-                       custom.hcenter = hcenter2hw(par->hcenter);
-                       custom.vtotal = vtotal2hw(par->vtotal);
-                       custom.vbstrt = vbstrt2hw(par->vbstrt);
-                       custom.vbstop = vbstop2hw(par->vbstop);
-                       custom.vsstrt = vsstrt2hw(par->vsstrt);
-                       custom.vsstop = vsstop2hw(par->vsstop);
-               }
+       while (1) {
+               dst += dst_idx >> SHIFT_PER_LONG;
+               dst_idx &= (BITS_PER_LONG - 1);
+               src += src_idx >> SHIFT_PER_LONG;
+               src_idx &= (BITS_PER_LONG - 1);
+               bitcpy_rev(dst, dst_idx, src, src_idx, n);
+               if (!--bpp)
+                       break;
+               dst_idx += next_plane * 8;
+               src_idx += next_plane * 8;
        }
-       if (!IS_OCS || par->hsstop)
-               custom.beamcon0 = par->beamcon0;
-       if (IS_AGA)
-               custom.fmode = par->fmode;
+}
 
-       /*
-        * The minimum period for audio depends on htotal
-        */
 
-       amiga_audio_min_period = div16(par->htotal);
+static void amifb_copyarea(struct fb_info *info,
+                          const struct fb_copyarea *area)
+{
+       struct amifb_par *par = (struct amifb_par *)info->par;
+       int x2, y2;
+       u32 dx, dy, sx, sy, width, height;
+       unsigned long *dst, *src;
+       int dst_idx, src_idx;
+       int rev_copy = 0;
 
-       is_lace = par->bplcon0 & BPC0_LACE ? 1 : 0;
-#if 1
-       if (is_lace) {
-               i = custom.vposr >> 15;
-       } else {
-               custom.vposw = custom.vposr | 0x8000;
-               i = 1;
-       }
-#else
-       i = 1;
-       custom.vposw = custom.vposr | 0x8000;
-#endif
-       custom.cop2lc = (u_short *)ZTWO_PADDR(copdisplay.list[currentcop][i]);
-}
+       /* clip the destination */
+       x2 = area->dx + area->width;
+       y2 = area->dy + area->height;
+       dx = area->dx > 0 ? area->dx : 0;
+       dy = area->dy > 0 ? area->dy : 0;
+       x2 = x2 < info->var.xres_virtual ? x2 : info->var.xres_virtual;
+       y2 = y2 < info->var.yres_virtual ? y2 : info->var.yres_virtual;
+       width = x2 - dx;
+       height = y2 - dy;
 
-       /*
-        * (Un)Blank the screen (called by VBlank interrupt)
-        */
+       if (area->sx + dx < area->dx || area->sy + dy < area->dy)
+               return;
 
-static void ami_do_blank(void)
-{
-       struct amifb_par *par = &currentpar;
-#if defined(CONFIG_FB_AMIGA_AGA)
-       u_short bplcon3 = par->bplcon3;
-#endif
-       u_char red, green, blue;
+       /* update sx,sy */
+       sx = area->sx + (dx - area->dx);
+       sy = area->sy + (dy - area->dy);
 
-       if (do_blank > 0) {
-               custom.dmacon = DMAF_RASTER | DMAF_SPRITE;
-               red = green = blue = 0;
-               if (!IS_OCS && do_blank > 1) {
-                       switch (do_blank) {
-                       case FB_BLANK_VSYNC_SUSPEND:
-                               custom.hsstrt = hsstrt2hw(par->hsstrt);
-                               custom.hsstop = hsstop2hw(par->hsstop);
-                               custom.vsstrt = vsstrt2hw(par->vtotal + 4);
-                               custom.vsstop = vsstop2hw(par->vtotal + 4);
-                               break;
-                       case FB_BLANK_HSYNC_SUSPEND:
-                               custom.hsstrt = hsstrt2hw(par->htotal + 16);
-                               custom.hsstop = hsstop2hw(par->htotal + 16);
-                               custom.vsstrt = vsstrt2hw(par->vsstrt);
-                               custom.vsstop = vsstrt2hw(par->vsstop);
-                               break;
-                       case FB_BLANK_POWERDOWN:
-                               custom.hsstrt = hsstrt2hw(par->htotal + 16);
-                               custom.hsstop = hsstop2hw(par->htotal + 16);
-                               custom.vsstrt = vsstrt2hw(par->vtotal + 4);
-                               custom.vsstop = vsstop2hw(par->vtotal + 4);
-                               break;
-                       }
-                       if (!(par->beamcon0 & BMC0_VARBEAMEN)) {
-                               custom.htotal = htotal2hw(par->htotal);
-                               custom.vtotal = vtotal2hw(par->vtotal);
-                               custom.beamcon0 = BMC0_HARDDIS | BMC0_VARBEAMEN |
-                                                 BMC0_VARVSYEN | BMC0_VARHSYEN | BMC0_VARCSYEN;
-                       }
+       /* the source must be completely inside the virtual screen */
+       if (sx + width > info->var.xres_virtual ||
+                       sy + height > info->var.yres_virtual)
+               return;
+
+       if (dy > sy || (dy == sy && dx > sx)) {
+               dy += height;
+               sy += height;
+               rev_copy = 1;
+       }
+       dst = (unsigned long *)
+               ((unsigned long)info->screen_base & ~(BYTES_PER_LONG - 1));
+       src = dst;
+       dst_idx = ((unsigned long)info->screen_base & (BYTES_PER_LONG - 1)) * 8;
+       src_idx = dst_idx;
+       dst_idx += dy * par->next_line * 8 + dx;
+       src_idx += sy * par->next_line * 8 + sx;
+       if (rev_copy) {
+               while (height--) {
+                       dst_idx -= par->next_line * 8;
+                       src_idx -= par->next_line * 8;
+                       copy_one_line_rev(info->var.bits_per_pixel,
+                                         par->next_plane, dst, dst_idx, src,
+                                         src_idx, width);
                }
        } else {
-               custom.dmacon = DMAF_SETCLR | DMAF_RASTER | DMAF_SPRITE;
-               red = red0;
-               green = green0;
-               blue = blue0;
-               if (!IS_OCS) {
-                       custom.hsstrt = hsstrt2hw(par->hsstrt);
-                       custom.hsstop = hsstop2hw(par->hsstop);
-                       custom.vsstrt = vsstrt2hw(par->vsstrt);
-                       custom.vsstop = vsstop2hw(par->vsstop);
-                       custom.beamcon0 = par->beamcon0;
+               while (height--) {
+                       copy_one_line(info->var.bits_per_pixel,
+                                     par->next_plane, dst, dst_idx, src,
+                                     src_idx, width);
+                       dst_idx += par->next_line * 8;
+                       src_idx += par->next_line * 8;
                }
        }
-#if defined(CONFIG_FB_AMIGA_AGA)
-       if (IS_AGA) {
-               custom.bplcon3 = bplcon3;
-               custom.color[0] = rgb2hw8_high(red, green, blue);
-               custom.bplcon3 = bplcon3 | BPC3_LOCT;
-               custom.color[0] = rgb2hw8_low(red, green, blue);
-               custom.bplcon3 = bplcon3;
-       } else
-#endif
-#if defined(CONFIG_FB_AMIGA_ECS)
-       if (par->bplcon0 & BPC0_SHRES) {
-               u_short color, mask;
-               int i;
-
-               mask = 0x3333;
-               color = rgb2hw2(red, green, blue);
-               for (i = 12; i >= 0; i -= 4)
-                       custom.color[i] = ecs_palette[i] = (ecs_palette[i] & mask) | color;
-               mask <<= 2; color >>= 2;
-               for (i = 3; i >= 0; i--)
-                       custom.color[i] = ecs_palette[i] = (ecs_palette[i] & mask) | color;
-       } else
-#endif
-               custom.color[0] = rgb2hw4(red, green, blue);
-       is_blanked = do_blank > 0 ? do_blank : 0;
 }
 
-static int ami_get_fix_cursorinfo(struct fb_fix_cursorinfo *fix)
+
+static inline void expand_one_line(int bpp, unsigned long next_plane,
+                                  unsigned long *dst, int dst_idx, u32 n,
+                                  const u8 *data, u32 bgcolor, u32 fgcolor)
 {
-       struct amifb_par *par = &currentpar;
+       const unsigned long *src;
+       int src_idx;
 
-       fix->crsr_width = fix->crsr_xsize = par->crsr.width;
-       fix->crsr_height = fix->crsr_ysize = par->crsr.height;
-       fix->crsr_color1 = 17;
-       fix->crsr_color2 = 18;
-       return 0;
+       while (1) {
+               dst += dst_idx >> SHIFT_PER_LONG;
+               dst_idx &= (BITS_PER_LONG - 1);
+               if ((bgcolor ^ fgcolor) & 1) {
+                       src = (unsigned long *)
+                               ((unsigned long)data & ~(BYTES_PER_LONG - 1));
+                       src_idx = ((unsigned long)data & (BYTES_PER_LONG - 1)) * 8;
+                       if (fgcolor & 1)
+                               bitcpy(dst, dst_idx, src, src_idx, n);
+                       else
+                               bitcpy_not(dst, dst_idx, src, src_idx, n);
+                       /* set or clear */
+               } else
+                       bitfill32(dst, dst_idx, fgcolor & 1 ? ~0 : 0, n);
+               if (!--bpp)
+                       break;
+               bgcolor >>= 1;
+               fgcolor >>= 1;
+               dst_idx += next_plane * 8;
+       }
 }
 
-static int ami_get_var_cursorinfo(struct fb_var_cursorinfo *var, u_char __user *data)
+
+static void amifb_imageblit(struct fb_info *info, const struct fb_image *image)
 {
-       struct amifb_par *par = &currentpar;
-       register u_short *lspr, *sspr;
-#ifdef __mc68000__
-       register u_long datawords asm ("d2");
-#else
-       register u_long datawords;
-#endif
-       register short delta;
-       register u_char color;
-       short height, width, bits, words;
-       int size, alloc;
+       struct amifb_par *par = (struct amifb_par *)info->par;
+       int x2, y2;
+       unsigned long *dst;
+       int dst_idx;
+       const char *src;
+       u32 dx, dy, width, height, pitch;
 
-       size = par->crsr.height * par->crsr.width;
-       alloc = var->height * var->width;
-       var->height = par->crsr.height;
-       var->width = par->crsr.width;
-       var->xspot = par->crsr.spot_x;
-       var->yspot = par->crsr.spot_y;
-       if (size > var->height * var->width)
-               return -ENAMETOOLONG;
-       if (!access_ok(VERIFY_WRITE, data, size))
-               return -EFAULT;
-       delta = 1 << par->crsr.fmode;
-       lspr = lofsprite + (delta << 1);
-       if (par->bplcon0 & BPC0_LACE)
-               sspr = shfsprite + (delta << 1);
-       else
-               sspr = NULL;
-       for (height = (short)var->height - 1; height >= 0; height--) {
-               bits = 0; words = delta; datawords = 0;
-               for (width = (short)var->width - 1; width >= 0; width--) {
-                       if (bits == 0) {
-                               bits = 16; --words;
-#ifdef __mc68000__
-                               asm volatile ("movew %1@(%3:w:2),%0 ; swap %0 ; movew %1@+,%0"
-                                       : "=d" (datawords), "=a" (lspr) : "1" (lspr), "d" (delta));
-#else
-                               datawords = (*(lspr + delta) << 16) | (*lspr++);
-#endif
-                       }
-                       --bits;
-#ifdef __mc68000__
-                       asm volatile (
-                               "clrb %0 ; swap %1 ; lslw #1,%1 ; roxlb #1,%0 ; "
-                               "swap %1 ; lslw #1,%1 ; roxlb #1,%0"
-                               : "=d" (color), "=d" (datawords) : "1" (datawords));
-#else
-                       color = (((datawords >> 30) & 2)
-                                | ((datawords >> 15) & 1));
-                       datawords <<= 1;
-#endif
-                       put_user(color, data++);
-               }
-               if (bits > 0) {
-                       --words; ++lspr;
-               }
-               while (--words >= 0)
-                       ++lspr;
-#ifdef __mc68000__
-               asm volatile ("lea %0@(%4:w:2),%0 ; tstl %1 ; jeq 1f ; exg %0,%1\n1:"
-                       : "=a" (lspr), "=a" (sspr) : "0" (lspr), "1" (sspr), "d" (delta));
-#else
-               lspr += delta;
-               if (sspr) {
-                       u_short *tmp = lspr;
-                       lspr = sspr;
-                       sspr = tmp;
+       /*
+        * We could use hardware clipping but on many cards you get around
+        * hardware clipping by writing to framebuffer directly like we are
+        * doing here.
+        */
+       x2 = image->dx + image->width;
+       y2 = image->dy + image->height;
+       dx = image->dx;
+       dy = image->dy;
+       x2 = x2 < info->var.xres_virtual ? x2 : info->var.xres_virtual;
+       y2 = y2 < info->var.yres_virtual ? y2 : info->var.yres_virtual;
+       width  = x2 - dx;
+       height = y2 - dy;
+
+       if (image->depth == 1) {
+               dst = (unsigned long *)
+                       ((unsigned long)info->screen_base & ~(BYTES_PER_LONG - 1));
+               dst_idx = ((unsigned long)info->screen_base & (BYTES_PER_LONG - 1)) * 8;
+               dst_idx += dy * par->next_line * 8 + dx;
+               src = image->data;
+               pitch = (image->width + 7) / 8;
+               while (height--) {
+                       expand_one_line(info->var.bits_per_pixel,
+                                       par->next_plane, dst, dst_idx, width,
+                                       src, image->bg_color,
+                                       image->fg_color);
+                       dst_idx += par->next_line * 8;
+                       src += pitch;
                }
-#endif
+       } else {
+               c2p_planar(info->screen_base, image->data, dx, dy, width,
+                          height, par->next_line, par->next_plane,
+                          image->width, info->var.bits_per_pixel);
        }
-       return 0;
 }
 
-static int ami_set_var_cursorinfo(struct fb_var_cursorinfo *var, u_char __user *data)
+
+       /*
+        * Amiga Frame Buffer Specific ioctls
+        */
+
+static int amifb_ioctl(struct fb_info *info,
+                      unsigned int cmd, unsigned long arg)
 {
-       struct amifb_par *par = &currentpar;
-       register u_short *lspr, *sspr;
-#ifdef __mc68000__
-       register u_long datawords asm ("d2");
-#else
-       register u_long datawords;
-#endif
-       register short delta;
-       u_short fmode;
-       short height, width, bits, words;
+       union {
+               struct fb_fix_cursorinfo fix;
+               struct fb_var_cursorinfo var;
+               struct fb_cursorstate state;
+       } crsr;
+       void __user *argp = (void __user *)arg;
+       int i;
 
-       if (!var->width)
-               return -EINVAL;
-       else if (var->width <= 16)
-               fmode = TAG_FMODE_1;
-       else if (var->width <= 32)
-               fmode = TAG_FMODE_2;
-       else if (var->width <= 64)
-               fmode = TAG_FMODE_4;
-       else
-               return -EINVAL;
-       if (fmode > maxfmode)
-               return -EINVAL;
-       if (!var->height)
-               return -EINVAL;
-       if (!access_ok(VERIFY_READ, data, var->width * var->height))
-               return -EFAULT;
-       delta = 1 << fmode;
-       lofsprite = shfsprite = (u_short *)spritememory;
-       lspr = lofsprite + (delta << 1);
-       if (par->bplcon0 & BPC0_LACE) {
-               if (((var->height + 4) << fmode << 2) > SPRITEMEMSIZE)
-                       return -EINVAL;
-               memset(lspr, 0, (var->height + 4) << fmode << 2);
-               shfsprite += ((var->height + 5)&-2) << fmode;
-               sspr = shfsprite + (delta << 1);
-       } else {
-               if (((var->height + 2) << fmode << 2) > SPRITEMEMSIZE)
-                       return -EINVAL;
-               memset(lspr, 0, (var->height + 2) << fmode << 2);
-               sspr = NULL;
-       }
-       for (height = (short)var->height - 1; height >= 0; height--) {
-               bits = 16; words = delta; datawords = 0;
-               for (width = (short)var->width - 1; width >= 0; width--) {
-                       unsigned long tdata = 0;
-                       get_user(tdata, data);
-                       data++;
-#ifdef __mc68000__
-                       asm volatile (
-                               "lsrb #1,%2 ; roxlw #1,%0 ; swap %0 ; "
-                               "lsrb #1,%2 ; roxlw #1,%0 ; swap %0"
-                               : "=d" (datawords)
-                               : "0" (datawords), "d" (tdata));
-#else
-                       datawords = ((datawords << 1) & 0xfffefffe);
-                       datawords |= tdata & 1;
-                       datawords |= (tdata & 2) << (16 - 1);
-#endif
-                       if (--bits == 0) {
-                               bits = 16; --words;
-#ifdef __mc68000__
-                               asm volatile ("swap %2 ; movew %2,%0@(%3:w:2) ; swap %2 ; movew %2,%0@+"
-                                       : "=a" (lspr) : "0" (lspr), "d" (datawords), "d" (delta));
-#else
-                               *(lspr + delta) = (u_short) (datawords >> 16);
-                               *lspr++ = (u_short) (datawords & 0xffff);
-#endif
-                       }
-               }
-               if (bits < 16) {
-                       --words;
-#ifdef __mc68000__
-                       asm volatile (
-                               "swap %2 ; lslw %4,%2 ; movew %2,%0@(%3:w:2) ; "
-                               "swap %2 ; lslw %4,%2 ; movew %2,%0@+"
-                               : "=a" (lspr) : "0" (lspr), "d" (datawords), "d" (delta), "d" (bits));
-#else
-                       *(lspr + delta) = (u_short) (datawords >> (16 + bits));
-                       *lspr++ = (u_short) ((datawords & 0x0000ffff) >> bits);
-#endif
-               }
-               while (--words >= 0) {
-#ifdef __mc68000__
-                       asm volatile ("moveql #0,%%d0 ; movew %%d0,%0@(%2:w:2) ; movew %%d0,%0@+"
-                               : "=a" (lspr) : "0" (lspr), "d" (delta) : "d0");
-#else
-                       *(lspr + delta) = 0;
-                       *lspr++ = 0;
-#endif
-               }
-#ifdef __mc68000__
-               asm volatile ("lea %0@(%4:w:2),%0 ; tstl %1 ; jeq 1f ; exg %0,%1\n1:"
-                       : "=a" (lspr), "=a" (sspr) : "0" (lspr), "1" (sspr), "d" (delta));
-#else
-               lspr += delta;
-               if (sspr) {
-                       u_short *tmp = lspr;
-                       lspr = sspr;
-                       sspr = tmp;
-               }
-#endif
-       }
-       par->crsr.height = var->height;
-       par->crsr.width = var->width;
-       par->crsr.spot_x = var->xspot;
-       par->crsr.spot_y = var->yspot;
-       par->crsr.fmode = fmode;
-       if (IS_AGA) {
-               par->fmode &= ~(FMODE_SPAGEM | FMODE_SPR32);
-               par->fmode |= sprfetchmode[fmode];
-               custom.fmode = par->fmode;
+       switch (cmd) {
+       case FBIOGET_FCURSORINFO:
+               i = ami_get_fix_cursorinfo(&crsr.fix);
+               if (i)
+                       return i;
+               return copy_to_user(argp, &crsr.fix,
+                                   sizeof(crsr.fix)) ? -EFAULT : 0;
+
+       case FBIOGET_VCURSORINFO:
+               i = ami_get_var_cursorinfo(&crsr.var,
+                       ((struct fb_var_cursorinfo __user *)arg)->data);
+               if (i)
+                       return i;
+               return copy_to_user(argp, &crsr.var,
+                                   sizeof(crsr.var)) ? -EFAULT : 0;
+
+       case FBIOPUT_VCURSORINFO:
+               if (copy_from_user(&crsr.var, argp, sizeof(crsr.var)))
+                       return -EFAULT;
+               return ami_set_var_cursorinfo(&crsr.var,
+                       ((struct fb_var_cursorinfo __user *)arg)->data);
+
+       case FBIOGET_CURSORSTATE:
+               i = ami_get_cursorstate(&crsr.state);
+               if (i)
+                       return i;
+               return copy_to_user(argp, &crsr.state,
+                                   sizeof(crsr.state)) ? -EFAULT : 0;
+
+       case FBIOPUT_CURSORSTATE:
+               if (copy_from_user(&crsr.state, argp, sizeof(crsr.state)))
+                       return -EFAULT;
+               return ami_set_cursorstate(&crsr.state);
        }
-       return 0;
+       return -EINVAL;
 }
 
-static int ami_get_cursorstate(struct fb_cursorstate *state)
-{
-       struct amifb_par *par = &currentpar;
 
-       state->xoffset = par->crsr.crsr_x;
-       state->yoffset = par->crsr.crsr_y;
-       state->mode = cursormode;
-       return 0;
-}
+       /*
+        * Flash the cursor (called by VBlank interrupt)
+        */
 
-static int ami_set_cursorstate(struct fb_cursorstate *state)
+static int flash_cursor(void)
 {
-       struct amifb_par *par = &currentpar;
+       static int cursorcount = 1;
 
-       par->crsr.crsr_x = state->xoffset;
-       par->crsr.crsr_y = state->yoffset;
-       if ((cursormode = state->mode) == FB_CURSOR_OFF)
-               cursorstate = -1;
-       do_cursor = 1;
+       if (cursormode == FB_CURSOR_FLASH) {
+               if (!--cursorcount) {
+                       cursorstate = -cursorstate;
+                       cursorcount = cursorrate;
+                       if (!is_blanked)
+                               return 1;
+               }
+       }
        return 0;
 }
 
-static void ami_set_sprite(void)
+       /*
+        * VBlank Display Interrupt
+        */
+
+static irqreturn_t amifb_interrupt(int irq, void *dev_id)
 {
-       struct amifb_par *par = &currentpar;
-       copins *copl, *cops;
-       u_short hs, vs, ve;
-       u_long pl, ps, pt;
-       short mx, my;
+       if (do_vmode_pan || do_vmode_full)
+               ami_update_display();
 
-       cops = copdisplay.list[currentcop][0];
-       copl = copdisplay.list[currentcop][1];
-       ps = pl = ZTWO_PADDR(dummysprite);
-       mx = par->crsr.crsr_x - par->crsr.spot_x;
-       my = par->crsr.crsr_y - par->crsr.spot_y;
-       if (!(par->vmode & FB_VMODE_YWRAP)) {
-               mx -= par->xoffset;
-               my -= par->yoffset;
+       if (do_vmode_full)
+               ami_init_display();
+
+       if (do_vmode_pan) {
+               flash_cursor();
+               ami_rebuild_copper();
+               do_cursor = do_vmode_pan = 0;
+       } else if (do_cursor) {
+               flash_cursor();
+               ami_set_sprite();
+               do_cursor = 0;
+       } else {
+               if (flash_cursor())
+                       ami_set_sprite();
        }
-       if (!is_blanked && cursorstate > 0 && par->crsr.height > 0 &&
-           mx > -(short)par->crsr.width && mx < par->xres &&
-           my > -(short)par->crsr.height && my < par->yres) {
-               pl = ZTWO_PADDR(lofsprite);
-               hs = par->diwstrt_h + (mx << par->clk_shift) - 4;
-               vs = par->diwstrt_v + (my << par->line_shift);
-               ve = vs + (par->crsr.height << par->line_shift);
-               if (par->bplcon0 & BPC0_LACE) {
-                       ps = ZTWO_PADDR(shfsprite);
-                       lofsprite[0] = spr2hw_pos(vs, hs);
-                       shfsprite[0] = spr2hw_pos(vs + 1, hs);
-                       if (mod2(vs)) {
-                               lofsprite[1 << par->crsr.fmode] = spr2hw_ctl(vs, hs, ve);
-                               shfsprite[1 << par->crsr.fmode] = spr2hw_ctl(vs + 1, hs, ve + 1);
-                               pt = pl; pl = ps; ps = pt;
-                       } else {
-                               lofsprite[1 << par->crsr.fmode] = spr2hw_ctl(vs, hs, ve + 1);
-                               shfsprite[1 << par->crsr.fmode] = spr2hw_ctl(vs + 1, hs, ve);
-                       }
-               } else {
-                       lofsprite[0] = spr2hw_pos(vs, hs) | (IS_AGA && (par->fmode & FMODE_BSCAN2) ? 0x80 : 0);
-                       lofsprite[1 << par->crsr.fmode] = spr2hw_ctl(vs, hs, ve);
-               }
+
+       if (do_blank) {
+               ami_do_blank();
+               do_blank = 0;
        }
-       copl[cop_spr0ptrh].w[1] = highw(pl);
-       copl[cop_spr0ptrl].w[1] = loww(pl);
-       if (par->bplcon0 & BPC0_LACE) {
-               cops[cop_spr0ptrh].w[1] = highw(ps);
-               cops[cop_spr0ptrl].w[1] = loww(ps);
+
+       if (do_vmode_full) {
+               ami_reinit_copper();
+               do_vmode_full = 0;
        }
+       return IRQ_HANDLED;
 }
 
 
+static struct fb_ops amifb_ops = {
+       .owner          = THIS_MODULE,
+       .fb_check_var   = amifb_check_var,
+       .fb_set_par     = amifb_set_par,
+       .fb_setcolreg   = amifb_setcolreg,
+       .fb_blank       = amifb_blank,
+       .fb_pan_display = amifb_pan_display,
+       .fb_fillrect    = amifb_fillrect,
+       .fb_copyarea    = amifb_copyarea,
+       .fb_imageblit   = amifb_imageblit,
+       .fb_ioctl       = amifb_ioctl,
+};
+
+
        /*
-        * Initialise the Copper Initialisation List
+        * Allocate, Clear and Align a Block of Chip Memory
         */
 
-static void __init ami_init_copper(void)
+static void *aligned_chipptr;
+
+static inline u_long __init chipalloc(u_long size)
 {
-       copins *cop = copdisplay.init;
-       u_long p;
-       int i;
+       aligned_chipptr = amiga_chip_alloc(size, "amifb [RAM]");
+       if (!aligned_chipptr) {
+               pr_err("amifb: No Chip RAM for frame buffer");
+               return 0;
+       }
+       memset(aligned_chipptr, 0, size);
+       return (u_long)aligned_chipptr;
+}
 
-       if (!IS_OCS) {
-               (cop++)->l = CMOVE(BPC0_COLOR | BPC0_SHRES | BPC0_ECSENA, bplcon0);
-               (cop++)->l = CMOVE(0x0181, diwstrt);
-               (cop++)->l = CMOVE(0x0281, diwstop);
-               (cop++)->l = CMOVE(0x0000, diwhigh);
-       } else
-               (cop++)->l = CMOVE(BPC0_COLOR, bplcon0);
-       p = ZTWO_PADDR(dummysprite);
-       for (i = 0; i < 8; i++) {
-               (cop++)->l = CMOVE(0, spr[i].pos);
-               (cop++)->l = CMOVE(highw(p), sprpt[i]);
-               (cop++)->l = CMOVE2(loww(p), sprpt[i]);
+static inline void chipfree(void)
+{
+       if (aligned_chipptr)
+               amiga_chip_free(aligned_chipptr);
+}
+
+
+static void amifb_deinit(struct platform_device *pdev)
+{
+       if (fb_info.cmap.len)
+               fb_dealloc_cmap(&fb_info.cmap);
+       chipfree();
+       if (videomemory)
+               iounmap((void *)videomemory);
+       custom.dmacon = DMAF_ALL | DMAF_MASTER;
+}
+
+
+       /*
+        * Initialisation
+        */
+
+static int __init amifb_probe(struct platform_device *pdev)
+{
+       int tag, i, err = 0;
+       u_long chipptr;
+       u_int defmode;
+
+#ifndef MODULE
+       char *option = NULL;
+
+       if (fb_get_options("amifb", &option)) {
+               amifb_video_off();
+               return -ENODEV;
+       }
+       amifb_setup(option);
+#endif
+       custom.dmacon = DMAF_ALL | DMAF_MASTER;
+
+       switch (amiga_chipset) {
+#ifdef CONFIG_FB_AMIGA_OCS
+       case CS_OCS:
+               strcat(fb_info.fix.id, "OCS");
+default_chipset:
+               chipset = TAG_OCS;
+               maxdepth[TAG_SHRES] = 0;        /* OCS means no SHRES */
+               maxdepth[TAG_HIRES] = 4;
+               maxdepth[TAG_LORES] = 6;
+               maxfmode = TAG_FMODE_1;
+               defmode = amiga_vblank == 50 ? DEFMODE_PAL : DEFMODE_NTSC;
+               fb_info.fix.smem_len = VIDEOMEMSIZE_OCS;
+               break;
+#endif /* CONFIG_FB_AMIGA_OCS */
+
+#ifdef CONFIG_FB_AMIGA_ECS
+       case CS_ECS:
+               strcat(fb_info.fix.id, "ECS");
+               chipset = TAG_ECS;
+               maxdepth[TAG_SHRES] = 2;
+               maxdepth[TAG_HIRES] = 4;
+               maxdepth[TAG_LORES] = 6;
+               maxfmode = TAG_FMODE_1;
+               if (AMIGAHW_PRESENT(AMBER_FF))
+                       defmode = amiga_vblank == 50 ? DEFMODE_AMBER_PAL
+                                                    : DEFMODE_AMBER_NTSC;
+               else
+                       defmode = amiga_vblank == 50 ? DEFMODE_PAL
+                                                    : DEFMODE_NTSC;
+               if (amiga_chip_avail() - CHIPRAM_SAFETY_LIMIT >
+                   VIDEOMEMSIZE_ECS_2M)
+                       fb_info.fix.smem_len = VIDEOMEMSIZE_ECS_2M;
+               else
+                       fb_info.fix.smem_len = VIDEOMEMSIZE_ECS_1M;
+               break;
+#endif /* CONFIG_FB_AMIGA_ECS */
+
+#ifdef CONFIG_FB_AMIGA_AGA
+       case CS_AGA:
+               strcat(fb_info.fix.id, "AGA");
+               chipset = TAG_AGA;
+               maxdepth[TAG_SHRES] = 8;
+               maxdepth[TAG_HIRES] = 8;
+               maxdepth[TAG_LORES] = 8;
+               maxfmode = TAG_FMODE_4;
+               defmode = DEFMODE_AGA;
+               if (amiga_chip_avail() - CHIPRAM_SAFETY_LIMIT >
+                   VIDEOMEMSIZE_AGA_2M)
+                       fb_info.fix.smem_len = VIDEOMEMSIZE_AGA_2M;
+               else
+                       fb_info.fix.smem_len = VIDEOMEMSIZE_AGA_1M;
+               break;
+#endif /* CONFIG_FB_AMIGA_AGA */
+
+       default:
+#ifdef CONFIG_FB_AMIGA_OCS
+               printk("Unknown graphics chipset, defaulting to OCS\n");
+               strcat(fb_info.fix.id, "Unknown");
+               goto default_chipset;
+#else /* CONFIG_FB_AMIGA_OCS */
+               err = -ENODEV;
+               goto amifb_error;
+#endif /* CONFIG_FB_AMIGA_OCS */
+               break;
        }
 
-       (cop++)->l = CMOVE(IF_SETCLR | IF_COPER, intreq);
-       copdisplay.wait = cop;
-       (cop++)->l = CEND;
-       (cop++)->l = CMOVE(0, copjmp2);
-       cop->l = CEND;
-
-       custom.cop1lc = (u_short *)ZTWO_PADDR(copdisplay.init);
-       custom.copjmp1 = 0;
-}
+       /*
+        * Calculate the Pixel Clock Values for this Machine
+        */
 
-static void ami_reinit_copper(void)
-{
-       struct amifb_par *par = &currentpar;
+       {
+       u_long tmp = DIVUL(200000000000ULL, amiga_eclock);
 
-       copdisplay.init[cip_bplcon0].w[1] = ~(BPC0_BPU3 | BPC0_BPU2 | BPC0_BPU1 | BPC0_BPU0) & par->bplcon0;
-       copdisplay.wait->l = CWAIT(32, par->diwstrt_v - 4);
-}
+       pixclock[TAG_SHRES] = (tmp + 4) / 8;    /* SHRES:  35 ns / 28 MHz */
+       pixclock[TAG_HIRES] = (tmp + 2) / 4;    /* HIRES:  70 ns / 14 MHz */
+       pixclock[TAG_LORES] = (tmp + 1) / 2;    /* LORES: 140 ns /  7 MHz */
+       }
 
        /*
-        * Build the Copper List
+        * Replace the Tag Values with the Real Pixel Clock Values
         */
 
-static void ami_build_copper(void)
-{
-       struct amifb_par *par = &currentpar;
-       copins *copl, *cops;
-       u_long p;
-
-       currentcop = 1 - currentcop;
+       for (i = 0; i < NUM_TOTAL_MODES; i++) {
+               struct fb_videomode *mode = &ami_modedb[i];
+               tag = mode->pixclock;
+               if (tag == TAG_SHRES || tag == TAG_HIRES || tag == TAG_LORES) {
+                       mode->pixclock = pixclock[tag];
+               }
+       }
 
-       copl = copdisplay.list[currentcop][1];
+       /*
+        *  These monitor specs are for a typical Amiga monitor (e.g. A1960)
+        */
+       if (fb_info.monspecs.hfmin == 0) {
+               fb_info.monspecs.hfmin = 15000;
+               fb_info.monspecs.hfmax = 38000;
+               fb_info.monspecs.vfmin = 49;
+               fb_info.monspecs.vfmax = 90;
+       }
 
-       (copl++)->l = CWAIT(0, 10);
-       (copl++)->l = CMOVE(par->bplcon0, bplcon0);
-       (copl++)->l = CMOVE(0, sprpt[0]);
-       (copl++)->l = CMOVE2(0, sprpt[0]);
+       fb_info.fbops = &amifb_ops;
+       fb_info.par = &currentpar;
+       fb_info.flags = FBINFO_DEFAULT;
+       fb_info.device = &pdev->dev;
 
-       if (par->bplcon0 & BPC0_LACE) {
-               cops = copdisplay.list[currentcop][0];
+       if (!fb_find_mode(&fb_info.var, &fb_info, mode_option, ami_modedb,
+                         NUM_TOTAL_MODES, &ami_modedb[defmode], 4)) {
+               err = -EINVAL;
+               goto amifb_error;
+       }
 
-               (cops++)->l = CWAIT(0, 10);
-               (cops++)->l = CMOVE(par->bplcon0, bplcon0);
-               (cops++)->l = CMOVE(0, sprpt[0]);
-               (cops++)->l = CMOVE2(0, sprpt[0]);
+       fb_videomode_to_modelist(ami_modedb, NUM_TOTAL_MODES,
+                                &fb_info.modelist);
 
-               (copl++)->l = CMOVE(diwstrt2hw(par->diwstrt_h, par->diwstrt_v + 1), diwstrt);
-               (copl++)->l = CMOVE(diwstop2hw(par->diwstop_h, par->diwstop_v + 1), diwstop);
-               (cops++)->l = CMOVE(diwstrt2hw(par->diwstrt_h, par->diwstrt_v), diwstrt);
-               (cops++)->l = CMOVE(diwstop2hw(par->diwstop_h, par->diwstop_v), diwstop);
-               if (!IS_OCS) {
-                       (copl++)->l = CMOVE(diwhigh2hw(par->diwstrt_h, par->diwstrt_v + 1,
-                                           par->diwstop_h, par->diwstop_v + 1), diwhigh);
-                       (cops++)->l = CMOVE(diwhigh2hw(par->diwstrt_h, par->diwstrt_v,
-                                           par->diwstop_h, par->diwstop_v), diwhigh);
-#if 0
-                       if (par->beamcon0 & BMC0_VARBEAMEN) {
-                               (copl++)->l = CMOVE(vtotal2hw(par->vtotal), vtotal);
-                               (copl++)->l = CMOVE(vbstrt2hw(par->vbstrt + 1), vbstrt);
-                               (copl++)->l = CMOVE(vbstop2hw(par->vbstop + 1), vbstop);
-                               (cops++)->l = CMOVE(vtotal2hw(par->vtotal), vtotal);
-                               (cops++)->l = CMOVE(vbstrt2hw(par->vbstrt), vbstrt);
-                               (cops++)->l = CMOVE(vbstop2hw(par->vbstop), vbstop);
-                       }
-#endif
-               }
-               p = ZTWO_PADDR(copdisplay.list[currentcop][0]);
-               (copl++)->l = CMOVE(highw(p), cop2lc);
-               (copl++)->l = CMOVE2(loww(p), cop2lc);
-               p = ZTWO_PADDR(copdisplay.list[currentcop][1]);
-               (cops++)->l = CMOVE(highw(p), cop2lc);
-               (cops++)->l = CMOVE2(loww(p), cop2lc);
-               copdisplay.rebuild[0] = cops;
-       } else {
-               (copl++)->l = CMOVE(diwstrt2hw(par->diwstrt_h, par->diwstrt_v), diwstrt);
-               (copl++)->l = CMOVE(diwstop2hw(par->diwstop_h, par->diwstop_v), diwstop);
-               if (!IS_OCS) {
-                       (copl++)->l = CMOVE(diwhigh2hw(par->diwstrt_h, par->diwstrt_v,
-                                           par->diwstop_h, par->diwstop_v), diwhigh);
-#if 0
-                       if (par->beamcon0 & BMC0_VARBEAMEN) {
-                               (copl++)->l = CMOVE(vtotal2hw(par->vtotal), vtotal);
-                               (copl++)->l = CMOVE(vbstrt2hw(par->vbstrt), vbstrt);
-                               (copl++)->l = CMOVE(vbstop2hw(par->vbstop), vbstop);
-                       }
-#endif
-               }
+       round_down_bpp = 0;
+       chipptr = chipalloc(fb_info.fix.smem_len + SPRITEMEMSIZE +
+                           DUMMYSPRITEMEMSIZE + COPINITSIZE +
+                           4 * COPLISTSIZE);
+       if (!chipptr) {
+               err = -ENOMEM;
+               goto amifb_error;
        }
-       copdisplay.rebuild[1] = copl;
 
-       ami_update_par();
-       ami_rebuild_copper();
-}
+       assignchunk(videomemory, u_long, chipptr, fb_info.fix.smem_len);
+       assignchunk(spritememory, u_long, chipptr, SPRITEMEMSIZE);
+       assignchunk(dummysprite, u_short *, chipptr, DUMMYSPRITEMEMSIZE);
+       assignchunk(copdisplay.init, copins *, chipptr, COPINITSIZE);
+       assignchunk(copdisplay.list[0][0], copins *, chipptr, COPLISTSIZE);
+       assignchunk(copdisplay.list[0][1], copins *, chipptr, COPLISTSIZE);
+       assignchunk(copdisplay.list[1][0], copins *, chipptr, COPLISTSIZE);
+       assignchunk(copdisplay.list[1][1], copins *, chipptr, COPLISTSIZE);
 
        /*
-        * Rebuild the Copper List
-        *
-        * We only change the things that are not static
+        * access the videomem with writethrough cache
         */
+       fb_info.fix.smem_start = (u_long)ZTWO_PADDR(videomemory);
+       videomemory = (u_long)ioremap_writethrough(fb_info.fix.smem_start,
+                                                  fb_info.fix.smem_len);
+       if (!videomemory) {
+               printk("amifb: WARNING! unable to map videomem cached writethrough\n");
+               fb_info.screen_base = (char *)ZTWO_VADDR(fb_info.fix.smem_start);
+       } else
+               fb_info.screen_base = (char *)videomemory;
 
-static void ami_rebuild_copper(void)
-{
-       struct amifb_par *par = &currentpar;
-       copins *copl, *cops;
-       u_short line, h_end1, h_end2;
-       short i;
-       u_long p;
+       memset(dummysprite, 0, DUMMYSPRITEMEMSIZE);
 
-       if (IS_AGA && maxfmode + par->clk_shift == 0)
-               h_end1 = par->diwstrt_h - 64;
-       else
-               h_end1 = par->htotal - 32;
-       h_end2 = par->ddfstop + 64;
+       /*
+        * Enable Display DMA
+        */
 
-       ami_set_sprite();
+       custom.dmacon = DMAF_SETCLR | DMAF_MASTER | DMAF_RASTER | DMAF_COPPER |
+                       DMAF_BLITTER | DMAF_SPRITE;
 
-       copl = copdisplay.rebuild[1];
-       p = par->bplpt0;
-       if (par->vmode & FB_VMODE_YWRAP) {
-               if ((par->vyres - par->yoffset) != 1 || !mod2(par->diwstrt_v)) {
-                       if (par->yoffset > par->vyres - par->yres) {
-                               for (i = 0; i < (short)par->bpp; i++, p += par->next_plane) {
-                                       (copl++)->l = CMOVE(highw(p), bplpt[i]);
-                                       (copl++)->l = CMOVE2(loww(p), bplpt[i]);
-                               }
-                               line = par->diwstrt_v + ((par->vyres - par->yoffset) << par->line_shift) - 1;
-                               while (line >= 512) {
-                                       (copl++)->l = CWAIT(h_end1, 510);
-                                       line -= 512;
-                               }
-                               if (line >= 510 && IS_AGA && maxfmode + par->clk_shift == 0)
-                                       (copl++)->l = CWAIT(h_end1, line);
-                               else
-                                       (copl++)->l = CWAIT(h_end2, line);
-                               p = par->bplpt0wrap;
-                       }
-               } else
-                       p = par->bplpt0wrap;
-       }
-       for (i = 0; i < (short)par->bpp; i++, p += par->next_plane) {
-               (copl++)->l = CMOVE(highw(p), bplpt[i]);
-               (copl++)->l = CMOVE2(loww(p), bplpt[i]);
+       /*
+        * Make sure the Copper has something to do
+        */
+
+       ami_init_copper();
+
+       if (request_irq(IRQ_AMIGA_COPPER, amifb_interrupt, 0,
+                       "fb vertb handler", &currentpar)) {
+               err = -EBUSY;
+               goto amifb_error;
        }
-       copl->l = CEND;
 
-       if (par->bplcon0 & BPC0_LACE) {
-               cops = copdisplay.rebuild[0];
-               p = par->bplpt0;
-               if (mod2(par->diwstrt_v))
-                       p -= par->next_line;
-               else
-                       p += par->next_line;
-               if (par->vmode & FB_VMODE_YWRAP) {
-                       if ((par->vyres - par->yoffset) != 1 || mod2(par->diwstrt_v)) {
-                               if (par->yoffset > par->vyres - par->yres + 1) {
-                                       for (i = 0; i < (short)par->bpp; i++, p += par->next_plane) {
-                                               (cops++)->l = CMOVE(highw(p), bplpt[i]);
-                                               (cops++)->l = CMOVE2(loww(p), bplpt[i]);
-                                       }
-                                       line = par->diwstrt_v + ((par->vyres - par->yoffset) << par->line_shift) - 2;
-                                       while (line >= 512) {
-                                               (cops++)->l = CWAIT(h_end1, 510);
-                                               line -= 512;
-                                       }
-                                       if (line > 510 && IS_AGA && maxfmode + par->clk_shift == 0)
-                                               (cops++)->l = CWAIT(h_end1, line);
-                                       else
-                                               (cops++)->l = CWAIT(h_end2, line);
-                                       p = par->bplpt0wrap;
-                                       if (mod2(par->diwstrt_v + par->vyres -
-                                           par->yoffset))
-                                               p -= par->next_line;
-                                       else
-                                               p += par->next_line;
-                               }
-                       } else
-                               p = par->bplpt0wrap - par->next_line;
-               }
-               for (i = 0; i < (short)par->bpp; i++, p += par->next_plane) {
-                       (cops++)->l = CMOVE(highw(p), bplpt[i]);
-                       (cops++)->l = CMOVE2(loww(p), bplpt[i]);
-               }
-               cops->l = CEND;
+       err = fb_alloc_cmap(&fb_info.cmap, 1 << fb_info.var.bits_per_pixel, 0);
+       if (err)
+               goto amifb_error;
+
+       if (register_framebuffer(&fb_info) < 0) {
+               err = -EINVAL;
+               goto amifb_error;
        }
+
+       printk("fb%d: %s frame buffer device, using %dK of video memory\n",
+              fb_info.node, fb_info.fix.id, fb_info.fix.smem_len>>10);
+
+       return 0;
+
+amifb_error:
+       amifb_deinit(pdev);
+       return err;
 }
 
+
 static int __exit amifb_remove(struct platform_device *pdev)
 {
        unregister_framebuffer(&fb_info);