/*      $NetBSD: ite_cc.c,v 1.47 2023/01/06 10:28:28 tsutsui Exp $      */

/*
* Copyright (c) 1996 Leo Weppelman
* Copyright (c) 1994 Christian E. Hopps
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
*    must display the following acknowledgement:
*      This product includes software developed by Christian E. Hopps.
* 4. The name of the author may not be used to endorse or promote products
*    derived from this software without specific prior written permission
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: ite_cc.c,v 1.47 2023/01/06 10:28:28 tsutsui Exp $");

#include <sys/param.h>
#include <sys/conf.h>
#include <sys/proc.h>
#include <sys/ioctl.h>
#include <sys/tty.h>
#include <sys/systm.h>
#include <sys/queue.h>
#include <sys/termios.h>
#include <sys/malloc.h>
#include <sys/device.h>
#include <sys/device_impl.h>    /* XXX autoconf abuse */
#include <dev/cons.h>
#include <machine/cpu.h>
#include <atari/atari/device.h>
#include <atari/dev/itevar.h>
#include <atari/dev/iteioctl.h>
#include <atari/dev/grfioctl.h>
#include <atari/dev/grfabs_reg.h>
#include <atari/dev/grfvar.h>
#include <atari/dev/font.h>
#include <atari/dev/viewioctl.h>
#include <atari/dev/viewvar.h>

#include "grfcc.h"

/*
* This is what ip->priv points to;
* it contains local variables for custom-chip ites.
*/
struct ite_priv {
       u_char  **row_ptr;      /* array of pointers into the bitmap    */
       u_long  row_bytes;
       u_long  cursor_opt;
       u_short *column_offset; /* array of offsets for columns         */
       u_int   row_offset;     /* the row offset                       */
       u_short width;          /* the bitmap width                     */
       u_short underline;      /* where the underline goes             */
       u_short ft_x;           /* the font width                       */
       u_short ft_y;           /* the font height                      */
       u_char  *font_cell[256];/* the font pointer                     */
};
typedef struct ite_priv ipriv_t;

/*
* We need the following space to get an ite-console setup before
* the VM-system is brought up. We setup for a 1280x960 monitor with
* an 8x8 font.
*/
#define CONS_MAXROW     120     /* Max. number of rows on console       */
#define CONS_MAXCOL     160     /* Max. number of columns on console    */
static u_short  con_columns[CONS_MAXCOL];
static u_char   *con_rows[CONS_MAXROW];
static ipriv_t  con_ipriv;

extern font_info        font_info_8x8;
extern font_info        font_info_8x16;

static void view_init(struct ite_softc *);
static void view_deinit(struct ite_softc *);
static int  itecc_ioctl(struct ite_softc *, u_long, void *, int,
                                                       struct lwp *);
static int  ite_newsize(struct ite_softc *, struct itewinsize *);
static void cursor32(struct ite_softc *, int);
static void putc8(struct ite_softc *, int, int, int, int);
static void clear8(struct ite_softc *, int, int, int, int);
static void scroll8(struct ite_softc *, int, int, int, int);
static void scrollbmap(bmap_t *, u_short, u_short, u_short, u_short,
                                                       short, short);

/*
* grfcc config stuff
*/
static void grfccattach(device_t, device_t, void *);
static int  grfccmatch(device_t, cfdata_t, void *);
static int  grfccprint(void *, const char *);

CFATTACH_DECL_NEW(grfcc, sizeof(struct grf_softc),
   grfccmatch, grfccattach, NULL, NULL);

/*
* only used in console init.
*/
static struct cfdata *cfdata_grf   = NULL;

/*
* Probe functions we can use:
*/
#ifdef TT_VIDEO
void    tt_probe_video(MODES *);
#endif /* TT_VIDEO */
#ifdef FALCON_VIDEO
void    falcon_probe_video(MODES *);
#endif /* FALCON_VIDEO */

static int
grfccmatch(device_t parent, cfdata_t cf, void *aux)
{
       static int did_consinit = 0;
       static int must_probe = 1;
       grf_auxp_t *grf_auxp = aux;
       extern const struct cdevsw view_cdevsw;

       if (must_probe) {
               /*
                * Check if the layers we depend on exist
                */
               if (!(machineid & (ATARI_TT|ATARI_FALCON)))
                       return 0;
#ifdef TT_VIDEO
               if ((machineid & ATARI_TT) && !grfabs_probe(&tt_probe_video))
                       return 0;
#endif /* TT_VIDEO */
#ifdef FALCON_VIDEO
               if ((machineid & ATARI_FALCON) &&
                   !grfabs_probe(&falcon_probe_video))
                       return 0;
#endif /* FALCON_VIDEO */

               viewprobe();
               must_probe = 0;
       }

       if (atari_realconfig == 0) {
               /*
                * Early console init. Only match first unit.
                */
               if (did_consinit)
                       return 0;
               if ((*view_cdevsw.d_open)(cf->cf_unit, 0, 0, NULL))
                       return 0;
               cfdata_grf = cf;
               did_consinit = 1;
               return 1;
       }

       /*
        * Normal config. When we are called directly from the grfbus,
        * we only match the first unit. The attach function will call us for
        * the other configured units.
        */
       if (grf_auxp->from_bus_match && (did_consinit > 1))
               return 0;

       if (!grf_auxp->from_bus_match && (grf_auxp->unit != cf->cf_unit))
               return 0;

       /*
        * Final constraint: each grf needs a view....
        */
       if ((cfdata_grf == NULL) || (did_consinit > 1)) {
           if ((*view_cdevsw.d_open)(cf->cf_unit, 0, 0, NULL))
               return 0;
       }
       did_consinit = 2;
       return 1;
}

/*
* attach: initialize the grf-structure and try to attach an ite to us.
* note  : self is NULL during early console init.
*/
static void
grfccattach(device_t parent, device_t self, void *aux)
{
       static struct grf_softc congrf;
       static int first_attach = 1;
       grf_auxp_t *grf_bus_auxp = aux;
       grf_auxp_t grf_auxp;
       struct grf_softc *sc;
       int maj;
       extern const struct cdevsw grf_cdevsw;

       /*
        * find our major device number
        */
       maj = cdevsw_lookup_major(&grf_cdevsw);

       /*
        * Handle exception case: early console init
        */
       if (self == NULL) {
               struct device itedev;

               memset(&itedev, 0, sizeof(itedev));
               itedev.dv_private = &congrf;

               congrf.g_unit    = cfdata_grf->cf_unit;
               congrf.g_grfdev  = makedev(maj, congrf.g_unit);
               congrf.g_itedev  = (dev_t)-1;
               congrf.g_flags   = GF_ALIVE;
               congrf.g_mode    = grf_mode;
               congrf.g_conpri  = grfcc_cnprobe();
               congrf.g_viewdev = congrf.g_unit;
               grfcc_iteinit(&congrf);
               grf_viewsync(&congrf);

               /* Attach console ite */
               atari_config_found(cfdata_grf, &itedev, &congrf, grfccprint,
                   CFARGS_NONE);
               return;
       }

       sc = device_private(self);
       sc->g_device = self;
       sc->g_unit = device_unit(self);
       grfsp[sc->g_unit] = sc;

       if ((cfdata_grf != NULL) && (sc->g_unit == congrf.g_unit)) {
               /*
                * We inited earlier just copy the info, take care
                * not to copy the device struct though.
                */
               memcpy(&sc->g_display, &congrf.g_display,
                       (char *)&sc[1] - (char *)&sc->g_display);
       } else {
               sc->g_grfdev  = makedev(maj, sc->g_unit);
               sc->g_itedev  = (dev_t)-1;
               sc->g_flags   = GF_ALIVE;
               sc->g_mode    = grf_mode;
               sc->g_conpri  = 0;
               sc->g_viewdev = sc->g_unit;
               grfcc_iteinit(sc);
               grf_viewsync(sc);
       }

       aprint_normal(": width %d height %d", sc->g_display.gd_dwidth,
                   sc->g_display.gd_dheight);
       if (sc->g_display.gd_colors == 2)
               aprint_normal(" monochrome\n");
       else
               aprint_normal(" colors %d\n", sc->g_display.gd_colors);

       /*
        * try and attach an ite
        */
       config_found(self, sc /* XXX */, grfccprint, CFARGS_NONE);

       /*
        * If attaching the first unit, go ahead and 'find' the rest of us
        */
       if (first_attach) {
               first_attach = 0;
               grf_auxp.from_bus_match = 0;
               for (grf_auxp.unit=1; grf_auxp.unit < NGRFCC; grf_auxp.unit++) {
                       config_found(parent, &grf_auxp, grf_bus_auxp->busprint,
                           CFARGS_NONE);
               }
       }
}

static int
grfccprint(void *aux, const char *pnp)
{

       if (pnp)
               aprint_normal("ite at %s", pnp);
       return UNCONF;
}

/*
* called from grf_cc to return console priority
*/
int
grfcc_cnprobe(void)
{
       return CN_INTERNAL;
}
/*
* called from grf_cc to init ite portion of
* grf_softc struct
*/
void
grfcc_iteinit(struct grf_softc *sc)
{

       sc->g_itecursor = cursor32;
       sc->g_iteputc   = putc8;
       sc->g_iteclear  = clear8;
       sc->g_itescroll = scroll8;
       sc->g_iteinit   = view_init;
       sc->g_itedeinit = view_deinit;
}

static void
view_deinit(struct ite_softc *ip)
{
       ip->flags &= ~ITE_INITED;
}

static void
view_init(register struct ite_softc *ip)
{
       struct itewinsize       wsz;
       ipriv_t                 *cci;

       if ((cci = ip->priv) != NULL)
               return;

       ip->itexx_ioctl = itecc_ioctl;

#if defined(KFONT_8X8)
       ip->font = font_info_8x8;
#else
       ip->font = font_info_8x16;
#endif

       /* Find the correct set of rendering routines for this font.  */
       if (ip->font.width != 8)
               panic("kernel font size not supported");

       if (!atari_realconfig)
               ip->priv = cci = &con_ipriv;
       else
               ip->priv = cci = malloc(sizeof(*cci), M_DEVBUF, M_WAITOK);
       if (cci == NULL)
               panic("No memory for ite-view");
       memset(cci, 0, sizeof(*cci));

       cci->cursor_opt    = 0;
       cci->row_ptr       = NULL;
       cci->column_offset = NULL;

       wsz.x      = ite_default_x;
       wsz.y      = ite_default_y;
       wsz.width  = ite_default_width;
       wsz.height = ite_default_height;
       wsz.depth  = ite_default_depth;

       ite_newsize (ip, &wsz);

       /*
        * Only console will be turned on by default..
        */
       if (ip->flags & ITE_ISCONS)
               ip->grf->g_mode(ip->grf, GM_GRFON, NULL, 0, 0);
}

static int
ite_newsize(struct ite_softc *ip, struct itewinsize *winsz)
{
       struct view_size        vs;
       ipriv_t                 *cci = ip->priv;
       u_long                  i, j;
       int                     error = 0;
       view_t                  *view;
       extern const struct cdevsw view_cdevsw;

       vs.x      = winsz->x;
       vs.y      = winsz->y;
       vs.width  = winsz->width;
       vs.height = winsz->height;
       vs.depth  = winsz->depth;

       error = (*view_cdevsw.d_ioctl)(ip->grf->g_viewdev, VIOCSSIZE,
                                      (void *)&vs, 0, NOLWP);
       view  = viewview(ip->grf->g_viewdev);

       /*
        * Reinitialize our structs
        */
       ip->cols = view->display.width  / ip->font.width;
       ip->rows = view->display.height / ip->font.height;

       /*
        * save new values so that future opens use them
        * this may not be correct when we implement Virtual Consoles
        */
       ite_default_height = view->display.height;
       ite_default_width  = view->display.width;
       ite_default_x      = view->display.x;
       ite_default_y      = view->display.y;
       ite_default_depth  = view->bitmap->depth;

       if (cci->row_ptr && (cci->row_ptr != con_rows)) {
               free(cci->row_ptr, M_DEVBUF);
               cci->row_ptr = NULL;
       }
       if (cci->column_offset && (cci->column_offset != con_columns)) {
               free(cci->column_offset, M_DEVBUF);
               cci->column_offset = NULL;
       }

       if (!atari_realconfig) {
               cci->row_ptr       = con_rows;
               cci->column_offset = con_columns;
       } else {
               cci->row_ptr = malloc(sizeof(u_char *) * ip->rows,
                   M_DEVBUF, M_NOWAIT);
               cci->column_offset = malloc(sizeof(u_int) * ip->cols,
                   M_DEVBUF, M_NOWAIT);
       }

       if (!cci->row_ptr || !cci->column_offset)
               panic("No memory for ite-view");

       cci->width      = view->bitmap->bytes_per_row << 3;
       cci->underline  = ip->font.baseline + 1;
       cci->row_offset = view->bitmap->bytes_per_row;
       cci->ft_x       = ip->font.width;
       cci->ft_y       = ip->font.height;
       cci->row_bytes  = cci->row_offset * cci->ft_y;
       cci->row_ptr[0] = view->bitmap->plane;
       for (i = 1; i < ip->rows; i++)
               cci->row_ptr[i] = cci->row_ptr[i - 1] + cci->row_bytes;

       /*
        * Initialize the column offsets to point at the correct location
        * in the first plane. This definitely assumes a font width of 8!
        */
       j = view->bitmap->depth * 2;
       cci->column_offset[0] = 0;
       for (i = 1; i < ip->cols; i++)
               cci->column_offset[i] = ((i >> 1) * j) + (i & 1);

       /* initialize the font cell pointers */
       cci->font_cell[ip->font.font_lo] = ip->font.font_p;
       for (i = ip->font.font_lo + 1; i <= ip->font.font_hi; i++)
               cci->font_cell[i] = cci->font_cell[i - 1] + ip->font.height;

       return error;
}

int
itecc_ioctl(struct ite_softc *ip, u_long cmd, void * addr, int flag,
   struct lwp *l)
{
       struct winsize          ws;
       struct itewinsize       *is;
       int                     error = 0;
       view_t                  *view = viewview(ip->grf->g_viewdev);
       extern const struct cdevsw ite_cdevsw;
       extern const struct cdevsw view_cdevsw;

       switch (cmd) {
       case ITEIOCSWINSZ:
               is = (struct itewinsize *)addr;

               if (ite_newsize(ip, is))
                       error = ENOMEM;
               else {
                       view         = viewview(ip->grf->g_viewdev);
                       ws.ws_row    = ip->rows;
                       ws.ws_col    = ip->cols;
                       ws.ws_xpixel = view->display.width;
                       ws.ws_ypixel = view->display.height;
                       ite_reset(ip);
                       /*
                        * XXX tell tty about the change
                        * XXX this is messy, but works
                        */
                       (*ite_cdevsw.d_ioctl)(ip->grf->g_itedev, TIOCSWINSZ,
                                             (void *)&ws, 0, l);
               }
               break;
       case VIOCSCMAP:
       case VIOCGCMAP:
               /*
                * XXX watchout for that NOLWP. its not really the kernel
                * XXX talking these two commands don't use the proc pointer
                * XXX though.
                */
               error = (*view_cdevsw.d_ioctl)(ip->grf->g_viewdev, cmd, addr,
                                              flag, NOLWP);
               break;
       default:
               error = EPASSTHROUGH;
               break;
       }
       return error;
}

static void
cursor32(struct ite_softc *ip, int flag)
{
       int     cend;
       u_char  *pl;
       ipriv_t *cci;

       cci = ip->priv;

       if (flag == END_CURSOROPT)
               cci->cursor_opt--;
       else if (flag == START_CURSOROPT) {
               if (!cci->cursor_opt)
                       cursor32(ip, ERASE_CURSOR);
               cci->cursor_opt++;
               return;           /* if we are already opted. */
       }

       if (cci->cursor_opt)
               return;           /* if we are still nested. */
                                 /* else we draw the cursor. */

       if (flag != DRAW_CURSOR && flag != END_CURSOROPT) {
               /*
                * erase the cursor
                */
               cend = ip->font.height - 1;
               pl   = cci->column_offset[ip->cursorx]
                               + cci->row_ptr[ip->cursory];
               __asm volatile
                       ("1: notb  %0@ ; addaw %4,%0\n\t"
                        "dbra  %1,1b"
                        : "=a" (pl), "=d" (cend)
                        : "0" (pl), "1" (cend),
                        "d" (cci->row_offset)
                        );
       }

       if (flag != DRAW_CURSOR && flag != MOVE_CURSOR && flag != END_CURSOROPT)
               return;

       /*
        * draw the cursor
        */
       cend = uimin(ip->curx, ip->cols - 1);
       if (flag == DRAW_CURSOR
               && ip->cursorx == cend && ip->cursory == ip->cury)
               return;
       ip->cursorx = cend;
       ip->cursory = ip->cury;
       cend        = ip->font.height - 1;
       pl          = cci->column_offset[ip->cursorx]
                       + cci->row_ptr[ip->cursory];

       __asm volatile
               ("1: notb  %0@ ; addaw %4,%0\n\t"
                "dbra  %1,1b"
                : "=a" (pl), "=d" (cend)
                : "0" (pl), "1" (cend),
                "d" (cci->row_offset)
                );
}

static void
putc8(struct ite_softc *ip, int c, int dy, int dx, int mode)
{
       ipriv_t *cci = (ipriv_t *)ip->priv;
       u_char  *pl  = cci->column_offset[dx] + cci->row_ptr[dy];
       u_int   fh   = cci->ft_y;
       u_int   ro   = cci->row_offset;
       u_char  eor_mask;
       u_char  bl, tmp, ul;
       u_char  *ft;

       if (c < ip->font.font_lo || c > ip->font.font_hi)
               return;

       /*
        * Handle DEC special graphics character by 'ESC ( B' sequence.
        * Note we assume all font data (fontdata_8x8 and fontdata_8x16)
        * contain DEC graphics glyph (for 0x5f to 0x7e) at 0x00 to 0x1F.
        */
       if (*ip->GL == CSET_DECGRAPH) {
               if (ip->font.font_lo == 0 && c >= 0x5f && c <= 0x7e)
                       c -= 0x5f;
       }
       ft = cci->font_cell[c];

       if (!mode) {
               while (fh--) {
                       *pl = *ft++; pl += ro;
               }
               return;
       }

       eor_mask = (mode & ATTR_INV) ? 0xff : 0x00;
       bl       = (mode & ATTR_BOLD) ? 1 : 0;
       ul       = (mode & ATTR_UL) ? fh - cci->underline : fh;
       for (; fh--; pl += ro) {
               if (fh != ul) {
                       tmp = *ft++;
                       if (bl)
                               tmp |= (tmp >> 1);
                       *pl = tmp ^ eor_mask;
               } else {
                       *pl = 0xff ^ eor_mask;
                       ft++;
               }
       }
}

static void
clear8(struct ite_softc *ip, int sy, int sx, int h, int w)
{
       ipriv_t *cci = (ipriv_t *) ip->priv;
       view_t  *v   = viewview(ip->grf->g_viewdev);
       bmap_t  *bm  = v->bitmap;

       if ((sx == 0) && (w == ip->cols)) {
               /* common case: clearing whole lines */
               while (h--) {
                       int i;
                       u_char *ptr = cci->row_ptr[sy];
                       for (i = 0; i < ip->font.height; i++) {
                               memset(ptr, 0, bm->bytes_per_row);
                               ptr += bm->bytes_per_row;
                       }
                       sy++;
               }
       } else {
               /*
                * clearing only part of a line
                * XXX could be optimized MUCH better, but is it worth the
                * trouble?
                */

               int i;
               u_char *pls, *ple;

               pls = cci->row_ptr[sy];
               ple = pls + cci->column_offset[sx + w - 1];
               pls = pls + cci->column_offset[sx];

               for (i = ((ip->font.height) * h) - 1; i >= 0; i--) {
                       u_char *p = pls;
                       while (p <= ple)
                               *p++ = 0;
                       pls += bm->bytes_per_row;
                       ple += bm->bytes_per_row;
               }
       }
}

/* Note: sx is only relevant for SCROLL_LEFT or SCROLL_RIGHT.  */
static void
scroll8(register struct ite_softc *ip, register int sy, int sx, int count,
   int dir)
{
       bmap_t *bm = viewview(ip->grf->g_viewdev)->bitmap;
       u_char *pl = ((ipriv_t *)ip->priv)->row_ptr[sy];

       if (dir == SCROLL_UP) {
               int dy = sy - count;

               cursor32(ip, ERASE_CURSOR);
               scrollbmap(bm, 0, dy * ip->font.height, bm->bytes_per_row >> 3,
                   (ip->bottom_margin - dy + 1) * ip->font.height,
                   0, -(count * ip->font.height));
       } else if (dir == SCROLL_DOWN) {
               cursor32(ip, ERASE_CURSOR);
               scrollbmap(bm, 0, sy * ip->font.height, bm->bytes_per_row >> 3,
                   (ip->bottom_margin - sy + 1) * ip->font.height,
                   0, count * ip->font.height);
       } else if (dir == SCROLL_RIGHT) {
               int sofs = (ip->cols - count) * ip->font.width;
               int dofs = (ip->cols) * ip->font.width;
               int i, j;

               cursor32(ip, ERASE_CURSOR);
               for (j = ip->font.height - 1; j >= 0; j--) {
                       int sofs2 = sofs, dofs2 = dofs;
                       for (i = (ip->cols - (sx + count)) - 1; i >= 0; i--) {
                               int t;
                               sofs2 -= ip->font.width;
                               dofs2 -= ip->font.width;
                               __asm("bfextu %1@{%2:%3}, %0" : "=d" (t)
                                   : "a" (pl), "d" (sofs2),
                                   "d" (ip->font.width));
                               __asm("bfins %3, %0@{%1:%2}" :
                                   : "a" (pl), "d" (dofs2),
                                   "d" (ip->font.width), "d" (t));
                       }
                       pl += bm->bytes_per_row;
               }
       } else { /* SCROLL_LEFT */
               int sofs = (sx) * ip->font.width;
               int dofs = (sx - count) * ip->font.width;
               int i, j;

               cursor32(ip, ERASE_CURSOR);
               for (j = ip->font.height - 1; j >= 0; j--) {
                       int sofs2 = sofs, dofs2 = dofs;
                       for (i = (ip->cols - sx) - 1; i >= 0; i--) {
                               int t;

                               __asm("bfextu %1@{%2:%3}, %0" : "=d" (t)
                                   : "a" (pl), "d" (sofs2),
                                   "d" (ip->font.width));
                               __asm("bfins %3, %0@{%1:%2}" :
                                   : "a" (pl), "d" (dofs2),
                                   "d" (ip->font.width), "d" (t));
                               sofs2 += ip->font.width;
                               dofs2 += ip->font.width;
                       }
                       pl += bm->bytes_per_row;
               }
       }
}

static void
scrollbmap (bmap_t *bm, u_short x, u_short y, u_short width, u_short height,
   short dx, short dy)
{
       u_short lwpr  = bm->bytes_per_row >> 2;

       if (dx) {
               /* FIX: */
               panic ("delta x not supported in scroll bitmap yet.");
       }

       if (dy == 0) {
               return;
       }
       if (dy > 0) {
               u_long *pl       = (u_long *)bm->plane;
               u_long *src_y    = pl + (lwpr * y);
               u_long *dest_y   = pl + (lwpr * (y + dy));
               u_long count     = lwpr * (height - dy);
               u_long *clr_y    = src_y;
               u_long clr_count = dest_y - src_y;
               u_long bc, cbc;

               src_y  += count - 1;
               dest_y += count - 1;

               bc = count >> 4;
               count &= 0xf;

               while (bc--) {
                       *dest_y-- = *src_y--; *dest_y-- = *src_y--;
                       *dest_y-- = *src_y--; *dest_y-- = *src_y--;
                       *dest_y-- = *src_y--; *dest_y-- = *src_y--;
                       *dest_y-- = *src_y--; *dest_y-- = *src_y--;
                       *dest_y-- = *src_y--; *dest_y-- = *src_y--;
                       *dest_y-- = *src_y--; *dest_y-- = *src_y--;
                       *dest_y-- = *src_y--; *dest_y-- = *src_y--;
                       *dest_y-- = *src_y--; *dest_y-- = *src_y--;
               }
               while (count--)
                       *dest_y-- = *src_y--;

               cbc = clr_count >> 4;
               clr_count &= 0xf;

               while (cbc--) {
                       *clr_y++ = 0; *clr_y++ = 0; *clr_y++ = 0; *clr_y++ = 0;
                       *clr_y++ = 0; *clr_y++ = 0; *clr_y++ = 0; *clr_y++ = 0;
                       *clr_y++ = 0; *clr_y++ = 0; *clr_y++ = 0; *clr_y++ = 0;
                       *clr_y++ = 0; *clr_y++ = 0; *clr_y++ = 0; *clr_y++ = 0;
               }
               while (clr_count--)
                       *clr_y++ = 0;
       } else {
               u_long  *pl       = (u_long *)bm->plane;
               u_long  *src_y    = pl + (lwpr * (y - dy));
               u_long  *dest_y   = pl + (lwpr * y);
               long    count     = lwpr * (height + dy);
               u_long  *clr_y    = dest_y + count;
               u_long  clr_count = src_y - dest_y;
               u_long  bc, cbc;

               bc = count >> 4;
               count &= 0xf;

               while (bc--) {
                       *dest_y++ = *src_y++; *dest_y++ = *src_y++;
                       *dest_y++ = *src_y++; *dest_y++ = *src_y++;
                       *dest_y++ = *src_y++; *dest_y++ = *src_y++;
                       *dest_y++ = *src_y++; *dest_y++ = *src_y++;
                       *dest_y++ = *src_y++; *dest_y++ = *src_y++;
                       *dest_y++ = *src_y++; *dest_y++ = *src_y++;
                       *dest_y++ = *src_y++; *dest_y++ = *src_y++;
                       *dest_y++ = *src_y++; *dest_y++ = *src_y++;
               }
               while (count--)
                       *dest_y++ = *src_y++;

               cbc = clr_count >> 4;
               clr_count &= 0xf;

               while (cbc--) {
                       *clr_y++ = 0; *clr_y++ = 0; *clr_y++ = 0; *clr_y++ = 0;
                       *clr_y++ = 0; *clr_y++ = 0; *clr_y++ = 0; *clr_y++ = 0;
                       *clr_y++ = 0; *clr_y++ = 0; *clr_y++ = 0; *clr_y++ = 0;
                       *clr_y++ = 0; *clr_y++ = 0; *clr_y++ = 0; *clr_y++ = 0;
               }
               while (clr_count--)
                       *clr_y++ = 0;
       }
}