/*      $NetBSD: diofb_mono.c,v 1.3 2025/05/31 18:50:33 tsutsui Exp $   */
/*      $OpenBSD: diofb_mono.c,v 1.3 2006/08/11 18:33:13 miod Exp $     */

/*
* Copyright (c) 2005, Miodrag Vallat.
* 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.
*
* 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.
*
*/
/*-
* Copyright (c) 1996, 1997 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Jason R. Thorpe.
*
* 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.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``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 FOUNDATION OR CONTRIBUTORS
* 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.
*/

/*
* Copyright (c) 1991 University of Utah.
* Copyright (c) 1990, 1993
*      The Regents of the University of California.  All rights reserved.
*
* This code is derived from software contributed to Berkeley by
* the Systems Programming Group of the University of Utah Computer
* Science Department and Mark Davies of the Department of Computer
* Science, Victoria University of Wellington, New Zealand.
*
* 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. Neither the name of the University nor the names of its contributors
*    may be used to endorse or promote products derived from this software
*    without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 REGENTS OR CONTRIBUTORS 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.
*
* from: Utah $Hdr: grf_hy.c 1.2 93/08/13$
*
*      @(#)grf_hy.c    8.4 (Berkeley) 1/12/94
*/

/*
* Graphics routines for real 1bpp frame buffers (i.e. pixels not being
* byte-addressed)
*/

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/bus.h>

#include <dev/wscons/wsconsio.h>
#include <dev/wscons/wsdisplayvar.h>
#include <dev/rasops/rasops.h>

#include <hp300/dev/diofbreg.h>
#include <hp300/dev/diofbvar.h>

#include <dev/rasops/rasops_masks.h>
#include <hp300/dev/maskbits.h>

int
diofb_mono_windowmove(struct diofb *fb, uint16_t sx, uint16_t sy,
   uint16_t dx, uint16_t dy, uint16_t cx, uint16_t cy, int16_t rop,
   int16_t planemask /* ignored */)
{
       int width;              /* add to get to same position in next line */

       uint32_t *psrcLine, *pdstLine;
                               /* pointers to line with current src and dst */
       uint32_t *psrc;         /* pointer to current src longword */
       uint32_t *pdst;         /* pointer to current dst longword */

                               /* following used for looping through a line */
       uint32_t startmask, endmask;  /* masks for writing ends of dst */
       int nlMiddle;           /* whole longwords in dst */
       int nl;                 /* temp copy of nlMiddle */
       int xoffSrc;            /* offset (>= 0, < 32) from which to
                                  fetch whole longwords fetched in src */
       int nstart;             /* number of ragged bits at start of dst */
       int nend;               /* number of ragged bits at end of dst */
       int srcStartOver;       /* pulling nstart bits from src
                                  overflows into the next word? */

       width = fb->fbwidth >> 5;

       if (sy < dy) {  /* start at last scanline of rectangle */
               psrcLine = ((uint32_t *)fb->fbkva) + ((sy + cy - 1) * width);
               pdstLine = ((uint32_t *)fb->fbkva) + ((dy + cy - 1) * width);
               width = -width;
       } else {        /* start at first scanline */
               psrcLine = ((uint32_t *)fb->fbkva) + (sy * width);
               pdstLine = ((uint32_t *)fb->fbkva) + (dy * width);
       }

       /* x direction doesn't matter for < 1 longword */
       if (cx <= 32) {
               int srcBit, dstBit;     /* bit offset of src and dst */

               pdstLine += (dx >> 5);
               psrcLine += (sx >> 5);
               psrc = psrcLine;
               pdst = pdstLine;

               srcBit = sx & 0x1f;
               dstBit = dx & 0x1f;

               while (cy-- > 0) {
                       getandputrop(psrc, srcBit, dstBit, cx, pdst, rop);
                       pdst += width;
                       psrc += width;
               }
       } else {
               maskbits(dx, cx, startmask, endmask, nlMiddle);
               if (startmask != 0)
                       nstart = 32 - (dx & 0x1f);
               else
                       nstart = 0;
               if (endmask != 0)
                       nend = (dx + cx) & 0x1f;
               else
                       nend = 0;

               xoffSrc = ((sx & 0x1f) + nstart) & 0x1f;
               srcStartOver = ((sx & 0x1f) + nstart) > 31;

               if (sx >= dx) { /* move left to right */
                       pdstLine += (dx >> 5);
                       psrcLine += (sx >> 5);

                       while (cy-- > 0) {
                               psrc = psrcLine;
                               pdst = pdstLine;

                               if (startmask != 0) {
                                       getandputrop(psrc, (sx & 0x1f),
                                           (dx & 0x1f), nstart, pdst, rop);
                                       pdst++;
                                       if (srcStartOver != 0)
                                               psrc++;
                               }

                               /* special case for aligned operations */
                               if (xoffSrc == 0) {
                                       nl = nlMiddle;
                                       while (nl-- > 0) {
                                               if (rop == RR_CLEAR)
                                                       *pdst = 0;
                                               else
                                                       *pdst = *psrc;
                                               psrc++;
                                               pdst++;
                                       }
                               } else {
                                       nl = nlMiddle + 1;
                                       while (--nl > 0) {
                                               if (rop == RR_CLEAR)
                                                       *pdst = 0;
                                               else
                                                       getunalignedword(psrc,
                                                           xoffSrc, *pdst);
                                               pdst++;
                                               psrc++;
                                       }
                               }

                               if (endmask != 0) {
                                       getandputrop(psrc, xoffSrc, 0, nend,
                                           pdst, rop);
                               }

                               pdstLine += width;
                               psrcLine += width;
                       }
               } else {        /* move right to left */
                       pdstLine += ((dx + cx) >> 5);
                       psrcLine += ((sx + cx) >> 5);
                       /*
                        * If fetch of last partial bits from source crosses
                        * a longword boundary, start at the previous longword
                        */
                       if (xoffSrc + nend >= 32)
                               --psrcLine;

                       while (cy-- > 0) {
                               psrc = psrcLine;
                               pdst = pdstLine;

                               if (endmask != 0) {
                                       getandputrop(psrc, xoffSrc, 0, nend,
                                           pdst, rop);
                               }

                               nl = nlMiddle + 1;
                               while (--nl > 0) {
                                       --psrc;
                                       --pdst;
                                       if (rop == RR_CLEAR)
                                               *pdst = 0;
                                       else
                                               getunalignedword(psrc, xoffSrc,
                                                   *pdst);
                               }

                               if (startmask != 0) {
                                       if (srcStartOver != 0)
                                               --psrc;
                                       --pdst;
                                       getandputrop(psrc, (sx & 0x1f),
                                           (dx & 0x1f), nstart, pdst, rop);
                               }

                               pdstLine += width;
                               psrcLine += width;
                       }
               }
       }

       return 0;
}