/*      $NetBSD: grfabs_cc.c,v 1.39 2023/07/12 05:16:42 mlelstv Exp $ */

/*
* 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.
*/

/*
*  abstract interface for custom chips to the amiga abstract graphics driver.
*
*/

#include "opt_amigaccgrf.h"

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: grfabs_cc.c,v 1.39 2023/07/12 05:16:42 mlelstv Exp $");

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/errno.h>
#include <sys/queue.h>
#include <sys/intr.h>

#include <amiga/amiga/custom.h>
#include <amiga/amiga/cc.h>

#include <amiga/dev/grfabs_reg.h>
#include <amiga/dev/grfabs_ccreg.h>

monitor_t *m_this;
mdata_t *m_this_data;
const char *monitor_name = "CCMONITOR";
monitor_t monitor;
mdata_t monitor_data;
cop_t  *null_mode_copper_list;

#if defined (GRF_PAL)
#  if defined (GRF_A2024)
dmode_t pal_a2024_mode;
dmdata_t pal_a2024_mode_data;
cop_t  *pal_a2024_frames[F_QD_TOTAL];
u_char *hedley_init;            /* init bitplane. */
dmode_t *p24_this;
dmdata_t *p24_this_data;

dmode_t pal_hires_dlace_mode;
dmdata_t pal_hires_dlace_mode_data;
cop_t  *pal_hires_dlace_frames[F_LACE_TOTAL];
dmode_t *phdl_this;
dmdata_t *phdl_this_data;
#  endif /* GRF_A2024 */

#  if defined (GRF_AGA)
dmode_t paga_mode;
dmdata_t paga_mode_data;
cop_t *paga_frames[F_TOTAL];
dmode_t *paga_this;
dmdata_t *paga_this_data;

#  endif /* GRF_AGA */

dmode_t pal_hires_lace_mode;
dmdata_t pal_hires_lace_mode_data;
cop_t  *pal_hires_lace_frames[F_LACE_TOTAL];
dmode_t *phl_this;
dmdata_t *phl_this_data;

dmode_t pal_hires_mode;
dmdata_t pal_hires_mode_data;
cop_t  *pal_hires_frames[F_TOTAL];
dmode_t *ph_this;
dmdata_t *ph_this_data;
#endif /* PAL */

#if defined (GRF_NTSC)
#  if defined (GRF_A2024)
dmode_t a2024_mode;
dmdata_t a2024_mode_data;
cop_t  *a2024_frames[F_QD_TOTAL];
u_char *hedley_init;            /* init bitplane. */
dmode_t *a24_this;
dmdata_t *a24_this_data;

dmode_t hires_dlace_mode;
dmdata_t hires_dlace_mode_data;
cop_t  *hires_dlace_frames[F_LACE_TOTAL];
dmode_t *hdl_this;
dmdata_t *hdl_this_data;
#  endif /* GRF_A2024 */

#  if defined (GRF_AGA)
dmode_t aga_mode;
dmdata_t aga_mode_data;
cop_t *aga_frames[F_TOTAL];
dmode_t *aga_this;
dmdata_t *aga_this_data;

#if defined (GRF_SUPER72)
dmode_t super72_mode;
dmdata_t super72_mode_data;
cop_t *super72_frames[F_LACE_TOTAL];
dmode_t *super72_this;
dmdata_t *super72_this_data;
#endif /* GRF_SUPER72 */

#  endif /* GRF_AGA */

dmode_t hires_lace_mode;
dmdata_t hires_lace_mode_data;
cop_t  *hires_lace_frames[F_LACE_TOTAL];
dmode_t *hl_this;
dmdata_t *hl_this_data;

void    display_hires_view(view_t * v);
dmode_t hires_mode;
dmdata_t hires_mode_data;
cop_t  *hires_frames[F_TOTAL];
dmode_t *h_this;
dmdata_t *h_this_data;
#endif /* GRF_NTSC */

#ifdef GRF_AGA
#define AGA_ENABLE      0x0001
#define AGA_ENABLE2     0x0002
#define AGA_TRACE       0x0004
#define AGA_TRACE2      0x0008
#define AGA_VGAONLY     0x0010
#define AGA_VGA31KHZ    0x0020

int aga_enable = 0;     /* set by start_c(), or can be patched */
colormap_t *cc_alloc_aga_colormap(int);
int cc_use_aga_colormap(view_t *, colormap_t *);
#endif

/* monitor functions. */
monitor_t *
cc_init_monitor(void)
{
       cop_t  *cp;

       if (m_this)
               return(m_this);

       cc_monitor = m_this = &monitor;
       /* turn sprite DMA off. we don't support them yet. */
       custom.dmacon = DMAF_SPRITE;

       /* make sure sprite data registers are clear as well */
       custom.spr[0].data = 0;
       custom.spr[0].datb = 0;

       m_this->name = monitor_name;
       m_this_data = m_this->data = &monitor_data;

       m_this->get_current_mode = get_current_mode;
       m_this->vbl_handler = (vbl_handler_func *) monitor_vbl_handler;
       m_this->get_next_mode = get_next_mode;
       m_this->get_best_mode = get_best_mode;

       m_this->alloc_bitmap = alloc_bitmap;
       m_this->free_bitmap = free_bitmap;

       m_this_data->current_mode = NULL;
       LIST_INIT(&m_this_data->modes);

       cp = null_mode_copper_list = alloc_chipmem(sizeof(cop_t) * 4);
       if (!cp)
               panic("no chipmem for grf.");

       CMOVE(cp, R_COLOR00, 0x0000);   /* background is black */
       CMOVE(cp, R_BPLCON0, 0x0000);   /* no planes to fetch from */
       CWAIT(cp, 255, 255);    /* COPEND */
       CWAIT(cp, 255, 255);    /* COPEND really */

       /* install this list and turn DMA on */
       custom.cop1lc = PREP_DMA_MEM(null_mode_copper_list);
       custom.copjmp1 = 0;
       custom.dmacon = DMAF_SETCLR | DMAF_MASTER | DMAF_RASTER \
           |DMAF_COPPER;

       cc_init_modes();
       LIST_INSERT_HEAD(monitors, m_this, link);
       return (m_this);
}

void
monitor_vbl_handler(monitor_t *m)
{
       dmdata_t *dmd;

       if (m_this_data->current_mode == NULL)
               return;

       dmd = DMDATA(m_this_data->current_mode);
       if (dmd)
               dmd->vbl_handler(m_this_data->current_mode);
}

dmode_t *
get_current_mode(void)
{
       if (m_this_data->current_mode)
               return(m_this_data->current_mode);
       else
               return(NULL);
}

dmode_t *
get_next_mode(dmode_t *d)
{
       if (d)
               return(d->link.le_next);
       return(m_this_data->modes.lh_first);
}

/* XXX needs to have more control attributes */
dmode_t *
get_best_mode(dimen_t *size, u_char depth)
{
       dmode_t *save;
       dmode_t *dm;
       long    dt = 0, dx, dy, ct;
       dmdata_t *dmd;

       save = NULL;
       dm = m_this_data->modes.lh_first;
       while (dm != NULL) {
               dmd = dm->data;
               if (depth > dmd->max_depth || depth < dmd->min_depth) {
                       dm = dm->link.le_next;
                       continue;
               } else if (size->width > dmd->max_size.width ||
                   size->height > dmd->max_size.height) {
                       dm = dm->link.le_next;
                       continue;
               } else if (size->width < dmd->min_size.width ||
                   size->height < dmd->min_size.height) {
                       dm = dm->link.le_next;
                       continue;
               }
               dx = abs(dm->nominal_size.width - size->width);
               dy = abs(dm->nominal_size.height - size->height);
               ct = dx + dy;

               if (ct < dt || save == NULL) {
                       save = dm;
                       dt = ct;
               }
               dm = dm->link.le_next;
       }
       return (save);
}
/* bitmap functions */
bmap_t *
alloc_bitmap(u_short width, u_short height, u_short depth, u_short flags)
{
       int     i;
       u_long  total_size;
#ifdef GRF_AGA
       u_short lwpr = (flags & BMF_ALIGN64) ? ((width + 63) / 64) * 2 :
           (width + 31) / 32;                  /* AGA needs 64 bit align */
#else
       u_short lwpr = (width + 31) / 32;
#endif
       u_short wpr = lwpr << 1;
       u_short bpr = wpr << 1;
       u_short array_size = sizeof(u_char *) * depth;
       u_long  plane_size = bpr * height;
       u_short temp_size = bpr + sizeof(u_long);
       bmap_t *bm;

       /* note the next allocation will give everything, also note that all
        * the stuff we want (including bitmaps) will be long short aligned.
        * This is a function of the data being allocated and the fact that
        * alloc_chipmem() returns long short aligned data. note also that
        * each row of the bitmap is long word aligned and made of exactly n
        * longwords. -ch */

       /* Sigh, it seems for mapping to work we need the bitplane data to 1:
        * be aligned on a page boundary. 2: be n pages large.
        *
        * why? because the user gets a page aligned address, if this is before
        * your allocation, too bad.  Also it seems that the mapping routines
        * do not watch to closely to the allowable length. so if you go over
        * n pages by less than another page, the user gets to write all over
        * the entire page.  Since you did not allocate up to a page boundary
        * (or more) the user writes into someone elses memory. -ch */
#ifdef __powerpc__
#define m68k_round_page(x)      ((((unsigned)(x)) + PGOFSET) & ~PGOFSET)
#endif
       total_size = m68k_round_page(plane_size * depth) +      /* for length */
           (temp_size) + (array_size) + sizeof(bmap_t) +
           PAGE_SIZE;          /* for alignment */
       bm = alloc_chipmem(total_size);
       if (bm) {
               if (flags & BMF_CLEAR) {
                       memset(bm, 0, total_size);
               }
               bm->bytes_per_row = bpr;
               bm->rows = height;
               bm->depth = depth;
               bm->flags = flags;
               bm->plane = (u_char **) & bm[1];
               bm->blit_temp = ((u_char *) bm->plane) + array_size;
               bm->plane[0] = (u_char *) m68k_round_page((u_long)
                                               (bm->blit_temp + temp_size));
               if (flags & BMF_INTERLEAVED) {
                       bm->row_mod = bm->bytes_per_row * (depth - 1);
                       for (i = 1; i < depth; i++) {
                               bm->plane[i] = bm->plane[i - 1] + bpr;
                       }
               } else {
                       bm->row_mod = 0;
                       for (i = 1; i < depth; i++) {
                               bm->plane[i] = bm->plane[i - 1] + plane_size;
                       }
               }
               bm->hardware_address = PREP_DMA_MEM(bm->plane[0]);
               return (bm);
       }
       return (NULL);
}


void
free_bitmap(bmap_t *bm)
{
       if (bm)
               free_chipmem(bm);
}
/* load a new mode into the current display, if NULL shut display off. */
void
cc_load_mode(dmode_t *d)
{
       if (d) {
               m_this_data->current_mode = d;
#ifdef __powerpc__      /* XXX ???? */
               custom.cop1lc = PREP_DMA_MEM(DMDATA(d)->frames[F_LONG]);
               custom.copjmp1 = 0;
#endif
               return;
       }
       /* turn off display */
       m_this_data->current_mode = NULL;
       wait_tof();
       wait_tof();
       custom.cop1lc = PREP_DMA_MEM(null_mode_copper_list);
       custom.copjmp1 = 0;
}
/*
* CC Mode Stuff.
*/

dmode_t *(*mode_init_funcs[]) (void) = {
#if defined (GRF_NTSC)
#if defined (GRF_A2024)
       cc_init_ntsc_a2024,
       cc_init_ntsc_hires_dlace,
#endif /* GRF_A2024 */
       cc_init_ntsc_hires_lace,
       cc_init_ntsc_hires,
#if defined (GRF_AGA)
       cc_init_ntsc_aga,
#if defined (GRF_SUPER72)
       cc_init_super72,
#endif /* GRF_SUPER72 */
#endif /* GRF_AGA */
#endif /* GRF_NTSC */
#if defined (GRF_PAL)
#if defined (GRF_A2024)
       cc_init_pal_a2024,
       cc_init_pal_hires_dlace,
#endif /* GRF_A2024 */
       cc_init_pal_hires_lace,
       cc_init_pal_hires,
#if defined (GRF_AGA)
       cc_init_pal_aga,
#endif /* GRF_AGA */
#endif /* GRF_PAL */
       NULL
};

int
cc_init_modes(void)
{
       int     i = 0;
       int     error = 0;
       while (mode_init_funcs[i]) {
               mode_init_funcs[i] ();
               i++;
       }
       return (error);
}

monitor_t *
cc_get_monitor(dmode_t *d)
{
       return (DMDATA(d)->monitor);
}

view_t *
cc_get_current_view(dmode_t *d)
{
       return (DMDATA(d)->current_view);
}


view_t *
cc_alloc_view(dmode_t *mode, dimen_t *dim, u_char depth)
{
       view_t *v = alloc_chipmem(sizeof(*v) + sizeof(vdata_t));
       if (v) {
               bmap_t *bm = cc_monitor->alloc_bitmap(dim->width, dim->height,
                   depth, BMF_CLEAR | (DMDATA(mode)->max_depth == 8 ? BMF_ALIGN64 : 0));
               if (bm) {
                       box_t   box;

                       v->data = &v[1];        /* at the end of view */
                       VDATA(v)->colormap = DMDATA(mode)->alloc_colormap(depth);
                       if (VDATA(v)->colormap) {
                               INIT_BOX(&box, 0, 0, dim->width, dim->height);
                               cc_init_view(v, bm, mode, &box);
                               return (v);
                       }
                       cc_monitor->free_bitmap(bm);
               }
               free_chipmem(v);
       }
       return (NULL);
}

colormap_t *
cc_alloc_colormap(int depth)
{
       u_long  size = 1U << depth, i;
       colormap_t *cm = alloc_chipmem(sizeof(u_long) * size + sizeof(*cm));

       if (cm) {
               cm->type = CM_COLOR;
               cm->red_mask = 0x0F;
               cm->green_mask = 0x0F;
               cm->blue_mask = 0x0F;
               cm->first = 0;
               cm->size = size;
               cm->entry = (u_long *) & cm[1]; /* table directly after. */
               for (i = 0; i < size; i++) {
                       cm->entry[i] = CM_WTOL(cc_default_colors[i&31]);
               }
               return (cm);
       }
       return (NULL);
}

#ifdef GRF_AGA
colormap_t *
cc_alloc_aga_colormap(int depth)
{
       u_long  size = 1U << depth, i;
       colormap_t *cm = alloc_chipmem(sizeof(u_long) * size + sizeof(*cm));

       if (cm) {
               cm->type = CM_COLOR;
               cm->red_mask = 0x0FF;
               cm->green_mask = 0x0FF;
               cm->blue_mask = 0x0FF;
               cm->first = 0;
               cm->size = size;
               cm->entry = (u_long *) & cm[1]; /* table directly after. */
               for (i = 0; i < size; i++) {
                       cm->entry[i] = CM_WTOL(cc_default_colors[i&31]) |
                           (CM_WTOL(cc_default_colors[i&31]) << 4);
               }
               return (cm);
       }
       return (NULL);
}
#endif

int
cc_colormap_checkvals(colormap_t *vcm, colormap_t *cm, int use)
{
       if (use) {
               /* check to see if its the view's colormap, if so just do
                * update. */
               if (vcm != cm) {
                       if (cm->first >= vcm->size ||
                          (cm->first + cm->size) > (cm->first + vcm->size) ||
                           cm->type != vcm->type) {
                               return (0);
                       }
                       switch (vcm->type) {
                       case CM_COLOR:
                               if (cm->red_mask != vcm->red_mask ||
                                   cm->green_mask != vcm->green_mask ||
                                   cm->blue_mask != vcm->blue_mask) {
                                       return (0);
                               }
                               break;
                       case CM_GREYSCALE:
                               if (cm->grey_mask != vcm->grey_mask) {
                                       return (0);
                               }
                               break;
                       }
               }
       } else {
               if (cm->first >= vcm->size ||
                  (cm->first + cm->size) > (cm->first + vcm->size)) {
                       return (0);
               }
       }
       return (1);
}

/* does sanity check on values */
int
cc_get_colormap(view_t *v, colormap_t *cm)
{
       colormap_t *vcm = VDATA(v)->colormap;
       int     i;

       if (!cc_colormap_checkvals(vcm, cm, 0)) {
               return (EINVAL);
       }
       cm->type = vcm->type;

       switch (vcm->type) {
       case CM_COLOR:
               cm->red_mask = vcm->red_mask;
               cm->green_mask = vcm->green_mask;
               cm->blue_mask = vcm->blue_mask;
               break;
       case CM_GREYSCALE:
               cm->grey_mask = vcm->grey_mask;
               break;
       }

       /* copy entries into colormap. */
       for (i = cm->first; i < (cm->first + cm->size); i++) {
               cm->entry[i] = vcm->entry[i];
       }
       return (0);
}

/* does sanity check on values */
int
cc_use_colormap(view_t *v, colormap_t *cm)
{
       colormap_t *vcm = VDATA(v)->colormap;
       int     s, i;

       if (!cc_colormap_checkvals(vcm, cm, 1)) {
               return (EINVAL);
       }
       /* check to see if its the view's colormap, if so just do update. */
       if (vcm != cm) {
               /* copy entries into colormap. */
               for (i = cm->first; i < (cm->first + cm->size); i++) {
                       vcm->entry[i] = cm->entry[i];
               }
       }
       s = spltty();

       /* is view currently being displayed? */
       if (VDATA(v)->flags & VF_DISPLAY) {
               /* yes, update the copper lists */
               cop_t  *tmp, *cp;
               int     nframes = 1, j;

               if (DMDATA(VDATA(v)->mode)->flags & DMF_INTERLACE) {
                       nframes = 2;
               }
               for (i = 0; i < nframes; i++) {
                       cp = DMDATA(VDATA(v)->mode)->frames[i];

                       tmp = find_copper_inst(cp, CI_MOVE(R_COLOR07));
                       tmp -= 7;

                       for (j = 0; j < 32; j++) {
                               CMOVE(tmp, (R_COLOR00 + (j << 1)),
                                       CM_LTOW(vcm->entry[j]));
                       }
               }
       }
       splx(s);
       return (0);
}

#ifdef GRF_AGA
/* does sanity check on values */
int
cc_use_aga_colormap(view_t *v, colormap_t *cm)
{
       colormap_t *vcm = VDATA(v)->colormap;
       int     s, i;

       if (!cc_colormap_checkvals(vcm, cm, 1)) {
               return (EINVAL);
       }
       /* check to see if its the view's colormap, if so just do update. */
       if (vcm != cm) {
               /* copy entries into colormap. */
               for (i = cm->first; i < (cm->first + cm->size); i++) {
                       vcm->entry[i] = cm->entry[i];
               }
       }
       s = spltty();

       /* is view currently being displayed? */
       if (VDATA(v)->flags & VF_DISPLAY) {
               /* yes, update the copper lists */
               cop_t  *tmp, *cp;
               int     nframes = 1, j;

               if (DMDATA(VDATA(v)->mode)->flags & DMF_INTERLACE) {
                       nframes = 2;
               }
               for (i = 0; i < nframes; i++) {
                       cp = DMDATA(VDATA(v)->mode)->frames[i];

                       tmp = find_copper_inst(cp, CI_MOVE(R_COLOR00));
                       for (j = 0; j < vcm->size; j += 32) {
                               int k;

                               for (k = 0; k < 32; k++) {
                                       int ce = vcm->entry[j + k] >> 4;
                                       CMOVE(tmp, (R_COLOR00 + (k << 1)),
                                               CM_LTOW(ce));
                               }
                               tmp++;
                               for (k = 0; k < 32; k++) {
                                       int ce =vcm->entry[j + k];
                                       CMOVE(tmp, (R_COLOR00 + (k << 1)),
                                               CM_LTOW(ce));
                               }
                               tmp++;
                       }
               }
       }
       splx(s);
       return (0);
}
#endif

#if defined (GRF_A2024)
colormap_t *
cc_a2024_alloc_colormap(int depth)
{
       u_long  size = 1U << depth, i;
       colormap_t *cm = alloc_chipmem(sizeof(u_long) * size + sizeof(*cm));

       if (cm) {
               cm->type = CM_GREYSCALE;
               cm->grey_mask = 0x03;
               cm->first = 0;
               cm->size = size;
               cm->entry = (u_long *) & cm[1]; /* table directly after. */
               for (i = 0; i < size; i++) {
                       cm->entry[i] = CM_WTOL(cc_a2024_default_colors[i]);
               }
               return (cm);
       }
       return (NULL);
}

int
cc_a2024_get_colormap(view_t *v, colormap_t *cm)
{
       /* there are no differences (yet) in the way the cm's are stored */
       return (cc_get_colormap(v, cm));
}

int
cc_a2024_use_colormap(view_t *v, colormap_t *cm)
{
       colormap_t *vcm = VDATA(v)->colormap;
       int     s, i;

       if (!cc_colormap_checkvals(vcm, cm, 1)) {
               return (EINVAL);
       }
       /* check to see if its the view's colormap, if so just do update. */
       if (vcm != cm) {
               /* copy entries into colormap. */
               for (i = cm->first; i < (cm->first + cm->size); i++) {
                       vcm->entry[i] = cm->entry[i];
               }
       }
       s = spltty();

       /* is view currently being displayed? */
       if (VDATA(v)->flags & VF_DISPLAY) {
               /* yes, update the copper lists */
               cop_t  *tmp, *cp;
               int     nframes = 2, nregs = cm->size == 4 ? 16 : 8, j;

               if (DMDATA(VDATA(v)->mode)->flags & DMF_HEDLEY_EXP) {
                       nframes = 4;
               }
               for (i = 0; i < nframes; i++) {
                       cp = DMDATA(VDATA(v)->mode)->frames[i];

                       tmp = find_copper_inst(cp, CI_MOVE(R_COLOR07));
                       tmp -= 7;

                       for (j = 0; j < nregs; j++) {
                               CMOVE(tmp, (R_COLOR00 + (j << 1)),
                                       A2024_CM_TO_CR(vcm, j));
                       }
               }
       }
       splx(s);
       return (0);
}
#endif /* GRF_A2024 */


/*
* CC View stuff.
*/

void
cc_init_view(view_t *v, bmap_t *bm, dmode_t *mode, box_t *dbox)
{
       vdata_t *vd = VDATA(v);
       v->bitmap = bm;
       vd->mode = mode;
       memcpy(&v->display, dbox, sizeof(box_t));

       v->display_view = DMDATA(vd->mode)->display_view;
       v->use_colormap = DMDATA(vd->mode)->use_colormap;
       v->get_colormap = DMDATA(vd->mode)->get_colormap;
       v->free_view = cc_free_view;
       v->get_display_mode = cc_get_display_mode;
       v->remove_view = cc_remove_view;
}

void
cc_free_view(view_t *v)
{
       if (v) {
               v->remove_view(v);
               free_chipmem(VDATA(v)->colormap);
               cc_monitor->free_bitmap(v->bitmap);
               free_chipmem(v);
       }
}

void
cc_remove_view(view_t *v)
{
       dmode_t *mode = VDATA(v)->mode;

       if (MDATA(cc_monitor)->current_mode == mode) {
               if (DMDATA(mode)->current_view == v) {
                       cc_load_mode(NULL);
               }
       }
       if (DMDATA(mode)->current_view == v) {
               DMDATA(mode)->current_view = NULL;
       }
       VDATA(v)->flags &= ~VF_DISPLAY;
}

dmode_t *
cc_get_display_mode(view_t *v)
{
       return (VDATA(v)->mode);
}

void
cc_mode_vbl_handler(dmode_t *d)
{
       u_short vp = ((custom.vposr & 0x0007) << 8) | ((custom.vhposr) >> 8);

       if (vp < 12) {
               custom.cop1lc = PREP_DMA_MEM(DMDATA(d)->frames[F_LONG]);
               custom.copjmp1 = 0;
       }
}

void
cc_lace_mode_vbl_handler(dmode_t *d)
{
       u_short vp = ((custom.vposr & 0x0007) << 8) | ((custom.vhposr) >> 8);

       if (vp < 12) {
               if (custom.vposr & 0x8000) {
                       custom.cop1lc = PREP_DMA_MEM(DMDATA(d)->frames[F_LACE_LONG]);
               } else {
                       custom.cop1lc = PREP_DMA_MEM(DMDATA(d)->frames[F_LACE_SHORT]);
               }
               custom.copjmp1 = 0;
       }
}

/*
* Modes. (ick)
*/

/*
* NTSC Modes
*/

#if defined (GRF_NTSC)

dmode_t *
cc_init_ntsc_hires(void)
{
       /* this function should only be called once. */
       if (!h_this) {
               u_short len = std_copper_list_len;

               h_this = &hires_mode;
               h_this_data = &hires_mode_data;
               memset(h_this, 0, sizeof(dmode_t));
               memset(h_this_data, 0, sizeof(dmdata_t));

               h_this->name = "ntsc: hires";
               h_this->nominal_size.width = 640;
               h_this->nominal_size.height = 200;
               h_this_data->max_size.width = 724;
               h_this_data->max_size.height = 242;
               h_this_data->min_size.width = 320;
               h_this_data->min_size.height = 100;
               h_this_data->min_depth = 1;
               h_this_data->max_depth = 4;
               h_this->data = h_this_data;

               h_this->get_monitor = cc_get_monitor;
               h_this->alloc_view = cc_alloc_view;
               h_this->get_current_view = cc_get_current_view;

               h_this_data->use_colormap = cc_use_colormap;
               h_this_data->get_colormap = cc_get_colormap;
               h_this_data->alloc_colormap = cc_alloc_colormap;
               h_this_data->display_view = display_hires_view;
               h_this_data->monitor = cc_monitor;

               h_this_data->frames = hires_frames;
               h_this_data->frames[F_LONG] =
                       alloc_chipmem(std_copper_list_size * F_TOTAL);
               if (!h_this_data->frames[F_LONG]) {
                       panic("couldn't get chipmem for copper list");
               }
               h_this_data->frames[F_STORE_LONG] =
                       &h_this_data->frames[F_LONG][len];

               memcpy(h_this_data->frames[F_STORE_LONG], std_copper_list,
                       std_copper_list_size);
               memcpy(h_this_data->frames[F_LONG], std_copper_list,
                       std_copper_list_size);

               h_this_data->bplcon0 = 0x8200 | USE_CON3;       /* hires, color
                                                                * composite enable */
               h_this_data->std_start_x = STANDARD_VIEW_X;
               h_this_data->std_start_y = STANDARD_VIEW_Y;
               h_this_data->vbl_handler =
                       (vbl_handler_func *) cc_mode_vbl_handler;
#if defined (GRF_ECS) || defined (GRF_AGA)
               h_this_data->beamcon0 = STANDARD_NTSC_BEAMCON;
#endif

               LIST_INSERT_HEAD(&MDATA(cc_monitor)->modes, h_this, link);
       }
       return (h_this);
}

void
display_hires_view(view_t *v)
{
       if (h_this_data->current_view != v) {
               vdata_t *vd = VDATA(v);
               cop_t  *cp = h_this_data->frames[F_STORE_LONG], *tmp;
               int     depth = v->bitmap->depth, i;
               int     hstart, hstop, vstart, vstop, j;
               int     x, y, w = v->display.width, h = v->display.height;
               u_short ddfstart, ddfwidth, con1;

               /* round down to nearest even width */
               /* w &= 0xfffe; */
               /* calculate datafetch width. */

               ddfwidth = ((v->bitmap->bytes_per_row >> 1) - 2) << 2;

               /* This will center the any overscanned display */
               /* and allow user to modify. */
               x = v->display.x + h_this_data->std_start_x - ((w - 640) >> 2);
               y = v->display.y + h_this_data->std_start_y - ((h - 200) >> 1);

               if (y & 1)
                       y--;

               if (!(x & 1))
                       x--;

               hstart = x;
               hstop = x + (w >> 1);
               vstart = y;
               vstop = y + h;
               ddfstart = (hstart - 9) >> 1;

               /* check for hardware limits, AGA may allow more..? */
               /* anyone got a 4000 I can borrow :^) -ch */
               if ((ddfstart & 0xfffc) + ddfwidth > 0xd8) {
                       int     d = 0;

                       /* XXX anyone know the equality properties of
                        * intermixed logical AND's */
                       /* XXX and arithmetic operators? */
                       while (((ddfstart & 0xfffc) + ddfwidth - d) > 0xd8) {
                               d++;
                       }

                       ddfstart -= d;
                       hstart -= d << 1;
                       hstop -= d << 1;
               }
               /* correct the datafetch to proper limits. */
               /* delay the actual display of the data until we need it. */
               ddfstart &= 0xfffc;
               con1 = ((hstart - 9) - (ddfstart << 1)) |
                       (((hstart - 9) - (ddfstart << 1)) << 4);

               if (h_this_data->current_view) {
                       VDATA(h_this_data->current_view)->flags &=
                               ~VF_DISPLAY;    /* mark as no longer displayed. */
               }
               h_this_data->current_view = v;

               cp = h_this_data->frames[F_STORE_LONG];
#if defined (GRF_ECS) || defined (GRF_AGA)
               tmp = find_copper_inst(cp, CI_MOVE(R_BPLCON3));
               tmp->cp.inst.operand = 0x0020;
#if defined (GRF_AGA)
               tmp = find_copper_inst(cp, CI_MOVE(R_FMODE));
               tmp->cp.inst.operand = 0;
#endif
               tmp = find_copper_inst(cp, CI_MOVE(R_BEAMCON0));
               tmp->cp.inst.operand = h_this_data->beamcon0;
               tmp = find_copper_inst(cp, CI_MOVE(R_DIWHIGH));
               tmp->cp.inst.operand = CALC_DIWHIGH(hstart, vstart, hstop, vstop);
#endif /* ECS */
               tmp = find_copper_inst(cp, CI_MOVE(R_BPLCON0));
               tmp->cp.inst.operand = h_this_data->bplcon0 | ((depth & 0x7) << 12);
               tmp = find_copper_inst(cp, CI_MOVE(R_BPLCON1));
               tmp->cp.inst.operand = con1;
               tmp = find_copper_inst(cp, CI_MOVE(R_DIWSTART));
               tmp->cp.inst.operand = ((vstart & 0xff) << 8) | (hstart & 0xff);
               tmp = find_copper_inst(cp, CI_MOVE(R_DIWSTOP));
               tmp->cp.inst.operand = ((vstop & 0xff) << 8) | (hstop & 0xff);
               tmp = find_copper_inst(cp, CI_MOVE(R_DDFSTART));
               tmp->cp.inst.operand = ddfstart;
               tmp = find_copper_inst(cp, CI_MOVE(R_DDFSTOP));
               tmp->cp.inst.operand = ddfstart + ddfwidth;

               tmp = find_copper_inst(cp, CI_MOVE(R_BPL0PTH));
               for (i = 0, j = 0; i < depth; j += 2, i++) {
                       /* update the plane pointers */
                       tmp[j].cp.inst.operand =
                               HIADDR(PREP_DMA_MEM(v->bitmap->plane[i]));
                       tmp[j + 1].cp.inst.operand =
                               LOADDR(PREP_DMA_MEM(v->bitmap->plane[i]));
               }

               /* set mods correctly. */
               tmp = find_copper_inst(cp, CI_MOVE(R_BPL1MOD));
               tmp[0].cp.inst.operand = v->bitmap->row_mod;
               tmp[1].cp.inst.operand = v->bitmap->row_mod;

               /* set next pointers correctly */
               tmp = find_copper_inst(cp, CI_MOVE(R_COP1LCH));
               tmp[0].cp.inst.operand =
                               HIADDR(PREP_DMA_MEM(h_this_data->frames[F_STORE_LONG]));
               tmp[1].cp.inst.operand =
                               LOADDR(PREP_DMA_MEM(h_this_data->frames[F_STORE_LONG]));

               cp = h_this_data->frames[F_LONG];
               h_this_data->frames[F_LONG] = h_this_data->frames[F_STORE_LONG];
               h_this_data->frames[F_STORE_LONG] = cp;

               vd->flags |= VF_DISPLAY;

               cc_use_colormap(v, vd->colormap);
       }
       cc_load_mode(h_this);
}

dmode_t *
cc_init_ntsc_hires_lace(void)
{
       /* this function should only be called once. */
       if (!hl_this) {
               u_short len = std_copper_list_len;

               hl_this = &hires_lace_mode;
               hl_this_data = &hires_lace_mode_data;
               memset(hl_this, 0, sizeof(dmode_t));
               memset(hl_this_data, 0, sizeof(dmdata_t));

               hl_this->name = "ntsc: hires interlace";
               hl_this->nominal_size.width = 640;
               hl_this->nominal_size.height = 400;
               hl_this_data->max_size.width = 724;
               hl_this_data->max_size.height = 482;
               hl_this_data->min_size.width = 320;
               hl_this_data->min_size.height = 200;
               hl_this_data->min_depth = 1;
               hl_this_data->max_depth = 4;
               hl_this->data = hl_this_data;

               hl_this->get_monitor = cc_get_monitor;
               hl_this->alloc_view = cc_alloc_view;
               hl_this->get_current_view = cc_get_current_view;

               hl_this_data->use_colormap = cc_use_colormap;
               hl_this_data->get_colormap = cc_get_colormap;
               hl_this_data->alloc_colormap = cc_alloc_colormap;
               hl_this_data->display_view = display_hires_lace_view;
               hl_this_data->monitor = cc_monitor;

               hl_this_data->flags |= DMF_INTERLACE;

               hl_this_data->frames = hires_lace_frames;
               hl_this_data->frames[F_LACE_LONG] =
                               alloc_chipmem(std_copper_list_size * F_LACE_TOTAL);
               if (!hl_this_data->frames[F_LACE_LONG]) {
                       panic("couldn't get chipmem for copper list");
               }
               hl_this_data->frames[F_LACE_SHORT] =
                               &hl_this_data->frames[F_LACE_LONG][len];
               hl_this_data->frames[F_LACE_STORE_LONG] =
                               &hl_this_data->frames[F_LACE_SHORT][len];
               hl_this_data->frames[F_LACE_STORE_SHORT] =
                               &hl_this_data->frames[F_LACE_STORE_LONG][len];

               memcpy(hl_this_data->frames[F_LACE_STORE_LONG], std_copper_list,
                       std_copper_list_size);
               memcpy(hl_this_data->frames[F_LACE_STORE_SHORT], std_copper_list,
                       std_copper_list_size);
               memcpy(hl_this_data->frames[F_LACE_LONG], std_copper_list,
                       std_copper_list_size);
               memcpy(hl_this_data->frames[F_LACE_SHORT], std_copper_list,
                       std_copper_list_size);

               hl_this_data->bplcon0 = 0x8204 | USE_CON3;      /* hires, color
                                                                * composite enable,
                                                                * lace. */
               hl_this_data->std_start_x = STANDARD_VIEW_X;
               hl_this_data->std_start_y = STANDARD_VIEW_Y;
               hl_this_data->vbl_handler =
                       (vbl_handler_func *) cc_lace_mode_vbl_handler;
#if defined (GRF_ECS) || defined (GRF_AGA)
               hl_this_data->beamcon0 = STANDARD_NTSC_BEAMCON;
#endif

               LIST_INSERT_HEAD(&MDATA(cc_monitor)->modes, hl_this, link);
       }
       return (hl_this);
}

void
display_hires_lace_view(view_t *v)
{
       if (hl_this_data->current_view != v) {
               vdata_t *vd = VDATA(v);
               cop_t  *cp = hl_this_data->frames[F_LACE_STORE_LONG], *tmp;
               int     depth = v->bitmap->depth, i;
               int     hstart, hstop, vstart, vstop, j;
               int     x, y, w = v->display.width, h = v->display.height;
               u_short ddfstart, ddfwidth, con1;

               /* round down to nearest even width */
               /* w &= 0xfffe; */


               /* calculate datafetch width. */

               ddfwidth = ((v->bitmap->bytes_per_row >> 1) - 2) << 2;

               /* This will center the any overscanned display */
               /* and allow user to modify. */
               x = v->display.x + hl_this_data->std_start_x - ((w - 640) >> 2);
               y = v->display.y + hl_this_data->std_start_y - ((h - 400) >> 2);

               if (y & 1)
                       y--;

               if (!(x & 1))
                       x--;

               hstart = x;
               hstop = x + (w >> 1);
               vstart = y;
               vstop = y + (h >> 1);
               ddfstart = (hstart - 9) >> 1;

               /* check for hardware limits, AGA may allow more..? */
               /* anyone got a 4000 I can borrow :^) -ch */
               if ((ddfstart & 0xfffc) + ddfwidth > 0xd8) {
                       int     d = 0;

                       /* XXX anyone know the equality properties of
                        * intermixed logial AND's */
                       /* XXX and arithmetic operators? */
                       while (((ddfstart & 0xfffc) + ddfwidth - d) > 0xd8) {
                               d++;
                       }

                       ddfstart -= d;
                       hstart -= d << 1;
                       hstop -= d << 1;
               }
               /* correct the datafetch to proper limits. */
               /* delay the actual display of the data until we need it. */
               ddfstart &= 0xfffc;
               con1 = ((hstart - 9) - (ddfstart << 1)) |
                               (((hstart - 9) - (ddfstart << 1)) << 4);

               if (hl_this_data->current_view) {
                       VDATA(hl_this_data->current_view)->flags &=
                               ~VF_DISPLAY;    /* mark as no longer displayed. */
               }
               hl_this_data->current_view = v;

               cp = hl_this_data->frames[F_LACE_STORE_LONG];
#if defined (GRF_ECS) || defined (GRF_AGA)
               tmp = find_copper_inst(cp, CI_MOVE(R_BPLCON3));
               tmp->cp.inst.operand = 0x0020;
#if defined (GRF_AGA)
               tmp = find_copper_inst(cp, CI_MOVE(R_FMODE));
               tmp->cp.inst.operand = 0;
#endif
               tmp = find_copper_inst(cp, CI_MOVE(R_BEAMCON0));
               tmp->cp.inst.operand = hl_this_data->beamcon0;
               tmp = find_copper_inst(cp, CI_MOVE(R_DIWHIGH));
               tmp->cp.inst.operand = CALC_DIWHIGH(hstart, vstart, hstop, vstop);
#endif /* ECS */
               tmp = find_copper_inst(cp, CI_MOVE(R_BPLCON0));
               tmp->cp.inst.operand = hl_this_data->bplcon0 | ((depth & 0x7) << 12);
               tmp = find_copper_inst(cp, CI_MOVE(R_BPLCON1));
               tmp->cp.inst.operand = con1;
               tmp = find_copper_inst(cp, CI_MOVE(R_DIWSTART));
               tmp->cp.inst.operand = ((vstart & 0xff) << 8) | (hstart & 0xff);
               tmp = find_copper_inst(cp, CI_MOVE(R_DIWSTOP));
               tmp->cp.inst.operand = ((vstop & 0xff) << 8) | (hstop & 0xff);
               tmp = find_copper_inst(cp, CI_MOVE(R_DDFSTART));
               tmp->cp.inst.operand = ddfstart;
               tmp = find_copper_inst(cp, CI_MOVE(R_DDFSTOP));
               tmp->cp.inst.operand = ddfstart + ddfwidth;

               tmp = find_copper_inst(cp, CI_MOVE(R_BPL0PTH));
               for (i = 0, j = 0; i < depth; j += 2, i++) {
                       /* update the plane pointers */
                       tmp[j].cp.inst.operand =
                               HIADDR(PREP_DMA_MEM(v->bitmap->plane[i]));
                       tmp[j + 1].cp.inst.operand =
                               LOADDR(PREP_DMA_MEM(v->bitmap->plane[i]));
               }

               /* set mods correctly. */
               tmp = find_copper_inst(cp, CI_MOVE(R_BPL1MOD));
               tmp[0].cp.inst.operand = v->bitmap->bytes_per_row + v->bitmap->row_mod;
               tmp[1].cp.inst.operand = v->bitmap->bytes_per_row + v->bitmap->row_mod;

               /* set next pointers correctly */
               tmp = find_copper_inst(cp, CI_MOVE(R_COP1LCH));
               tmp[0].cp.inst.operand =
                       HIADDR(PREP_DMA_MEM(hl_this_data->frames[F_LACE_STORE_SHORT]));
               tmp[1].cp.inst.operand =
                       LOADDR(PREP_DMA_MEM(hl_this_data->frames[F_LACE_STORE_SHORT]));


               bcopy(hl_this_data->frames[F_LACE_STORE_LONG],
                       hl_this_data->frames[F_LACE_STORE_SHORT], std_copper_list_size);

               /* these are the only ones that are different from long frame. */
               cp = hl_this_data->frames[F_LACE_STORE_SHORT];
               tmp = find_copper_inst(cp, CI_MOVE(R_BPL0PTH));
               for (i = 0, j = 0; i < depth; j += 2, i++) {
                       u_short mod = v->bitmap->bytes_per_row + v->bitmap->row_mod;
                       /* update plane pointers. high and low. */
                       tmp[j].cp.inst.operand =
                               HIADDR(PREP_DMA_MEM(&v->bitmap->plane[i][mod]));
                       tmp[j + 1].cp.inst.operand =
                               LOADDR(PREP_DMA_MEM(&v->bitmap->plane[i][mod]));
               }

               /* set next pointers correctly */
               tmp = find_copper_inst(cp, CI_MOVE(R_COP1LCH));
               tmp[0].cp.inst.operand =
                       HIADDR(PREP_DMA_MEM(hl_this_data->frames[F_LACE_STORE_LONG]));
               tmp[1].cp.inst.operand =
                       LOADDR(PREP_DMA_MEM(hl_this_data->frames[F_LACE_STORE_LONG]));


               cp = hl_this_data->frames[F_LACE_LONG];
               hl_this_data->frames[F_LACE_LONG] =
                       hl_this_data->frames[F_LACE_STORE_LONG];
               hl_this_data->frames[F_LACE_STORE_LONG] = cp;

               cp = hl_this_data->frames[F_LACE_SHORT];
               hl_this_data->frames[F_LACE_SHORT] =
                       hl_this_data->frames[F_LACE_STORE_SHORT];
               hl_this_data->frames[F_LACE_STORE_SHORT] = cp;

               vd->flags |= VF_DISPLAY;

               cc_use_colormap(v, vd->colormap);
       }
       cc_load_mode(hl_this);
}
#if defined (GRF_A2024)

dmode_t *
cc_init_ntsc_hires_dlace(void)
{
       /* this function should only be called once. */
       if (!hdl_this) {
               u_short len = std_dlace_copper_list_len;

               hdl_this = &hires_dlace_mode;
               hdl_this_data = &hires_dlace_mode_data;
               memset(hdl_this, 0, sizeof(dmode_t));
               memset(hdl_this_data, 0, sizeof(dmdata_t));

               hdl_this->name = "ntsc: hires double interlace";
               hdl_this->nominal_size.width = 640;
               hdl_this->nominal_size.height = 800;
               hdl_this_data->max_size.width = 724;
               hdl_this_data->max_size.height = 800;
               hdl_this_data->min_size.width = 320;
               hdl_this_data->min_size.height = 400;
               hdl_this_data->min_depth = 1;
               hdl_this_data->max_depth = 2;
               hdl_this->data = hdl_this_data;

               hdl_this->get_monitor = cc_get_monitor;
               hdl_this->alloc_view = cc_alloc_view;
               hdl_this->get_current_view = cc_get_current_view;

               hdl_this_data->use_colormap = cc_a2024_use_colormap;
               hdl_this_data->get_colormap = cc_a2024_get_colormap;
               hdl_this_data->alloc_colormap = cc_a2024_alloc_colormap;
               hdl_this_data->display_view = display_hires_dlace_view;
               hdl_this_data->monitor = cc_monitor;

               hdl_this_data->flags |= DMF_INTERLACE;

               hdl_this_data->frames = hires_dlace_frames;
               hdl_this_data->frames[F_LACE_LONG] =
                       alloc_chipmem(std_dlace_copper_list_size * F_LACE_TOTAL);
               if (!hdl_this_data->frames[F_LACE_LONG]) {
                       panic("couldn't get chipmem for copper list");
               }
               hdl_this_data->frames[F_LACE_SHORT] =
                       &hdl_this_data->frames[F_LACE_LONG][len];
               hdl_this_data->frames[F_LACE_STORE_LONG] =
                       &hdl_this_data->frames[F_LACE_SHORT][len];
               hdl_this_data->frames[F_LACE_STORE_SHORT] =
                       &hdl_this_data->frames[F_LACE_STORE_LONG][len];

               bcopy(std_dlace_copper_list,
                       hdl_this_data->frames[F_LACE_STORE_LONG],
                       std_dlace_copper_list_size);
               bcopy(std_dlace_copper_list,
                       hdl_this_data->frames[F_LACE_STORE_SHORT],
                       std_dlace_copper_list_size);
               bcopy(std_dlace_copper_list,
                       hdl_this_data->frames[F_LACE_LONG],
                       std_dlace_copper_list_size);
               bcopy(std_dlace_copper_list,
                       hdl_this_data->frames[F_LACE_SHORT],
                       std_dlace_copper_list_size);

               hdl_this_data->bplcon0 = 0x8204 | USE_CON3;     /* hires, color
                                                                * composite enable,
                                                                * dlace. */
               hdl_this_data->std_start_x = STANDARD_VIEW_X;
               hdl_this_data->std_start_y = STANDARD_VIEW_Y;
               hdl_this_data->vbl_handler =
                       (vbl_handler_func *) cc_lace_mode_vbl_handler;
#if defined (GRF_ECS) || defined (GRF_AGA)
               hdl_this_data->beamcon0 = STANDARD_NTSC_BEAMCON;
#endif
               LIST_INSERT_HEAD(&MDATA(cc_monitor)->modes, hdl_this, link);
       }
       return (hdl_this);
}

void
display_hires_dlace_view(view_t *v)
{
       if (hdl_this_data->current_view != v) {
               vdata_t *vd = VDATA(v);
               cop_t  *cp = hdl_this_data->frames[F_LACE_STORE_LONG], *tmp;
               int     depth = v->bitmap->depth;
               int     hstart, hstop, vstart, vstop;
               int     x, y, w = v->display.width, h = v->display.height;
               u_short ddfstart, ddfwidth, con1;
               u_short mod1l, mod2l;

               /* round down to nearest even width */
               /* w &= 0xfffe; */

               /* calculate datafetch width. */

               ddfwidth = ((v->bitmap->bytes_per_row >> 1) - 2) << 2;

               /* This will center the any overscanned display */
               /* and allow user to modify. */
               x = v->display.x + hdl_this_data->std_start_x - ((w - 640) >> 2);
               y = v->display.y + hdl_this_data->std_start_y - ((h - 800) >> 3);

               if (y & 1)
                       y--;

               if (!(x & 1))
                       x--;

               hstart = x;
               hstop = x + (w >> 1);
               vstart = y;
               vstop = y + (h >> 2);

               ddfstart = (hstart - 9) >> 1;

               /* check for hardware limits, AGA may allow more..? */
               /* anyone got a 4000 I can borrow :^) -ch */
               if ((ddfstart & 0xfffc) + ddfwidth > 0xd8) {
                       int     d = 0;

                       /* XXX anyone know the equality properties of
                        * intermixed logial AND's */
                       /* XXX and arithmetic operators? */
                       while (((ddfstart & 0xfffc) + ddfwidth - d) > 0xd8) {
                               d++;
                       }

                       ddfstart -= d;
                       hstart -= d << 1;
                       hstop -= d << 1;
               }
               /* correct the datafetch to proper limits. */
               /* delay the actual display of the data until we need it. */
               ddfstart &= 0xfffc;
               con1 = ((hstart - 9) - (ddfstart << 1)) |
                       (((hstart - 9) - (ddfstart << 1)) << 4);

               if (hdl_this_data->current_view) {
                       VDATA(hdl_this_data->current_view)->flags &=
                               ~VF_DISPLAY;    /* mark as no longer displayed. */
               }
               hdl_this_data->current_view = v;

               cp = hdl_this_data->frames[F_LACE_STORE_LONG];
#if defined (GRF_ECS) || defined (GRF_AGA)
               tmp = find_copper_inst(cp, CI_MOVE(R_BPLCON3));
               tmp->cp.inst.operand = 0x0020;
#if defined (GRF_AGA)
               tmp = find_copper_inst(cp, CI_MOVE(R_FMODE));
               tmp->cp.inst.operand = 0;
#endif
               tmp = find_copper_inst(cp, CI_MOVE(R_BEAMCON0));
               tmp->cp.inst.operand = hdl_this_data->beamcon0;
               tmp = find_copper_inst(cp, CI_MOVE(R_DIWHIGH));
               tmp->cp.inst.operand = CALC_DIWHIGH(hstart, vstart, hstop, vstop);
#endif /* ECS */
               tmp = find_copper_inst(cp, CI_MOVE(R_BPLCON0));
               tmp->cp.inst.operand =
                       hdl_this_data->bplcon0 | ((depth & 0x7) << 13); /* times two. */
               tmp = find_copper_inst(cp, CI_MOVE(R_BPLCON1));
               tmp->cp.inst.operand = con1;
               tmp = find_copper_inst(cp, CI_MOVE(R_DIWSTART));
               tmp->cp.inst.operand = ((vstart & 0xff) << 8) | (hstart & 0xff);
               tmp = find_copper_inst(cp, CI_MOVE(R_DIWSTOP));
               tmp->cp.inst.operand = ((vstop & 0xff) << 8) | (hstop & 0xff);
               tmp = find_copper_inst(cp, CI_MOVE(R_DDFSTART));
               tmp->cp.inst.operand = ddfstart;
               tmp = find_copper_inst(cp, CI_MOVE(R_DDFSTOP));
               tmp->cp.inst.operand = ddfstart + ddfwidth;

               mod1l = v->bitmap->bytes_per_row + v->bitmap->row_mod;
               mod2l = mod1l << 1;

               /* update plane pointers. */
               tmp = find_copper_inst(cp, CI_MOVE(R_BPL0PTH));
               tmp[0].cp.inst.operand =
                       HIADDR(PREP_DMA_MEM(&v->bitmap->plane[0][0]));
               tmp[1].cp.inst.operand =
                       LOADDR(PREP_DMA_MEM(&v->bitmap->plane[0][0]));
               tmp[2].cp.inst.operand =
                       HIADDR(PREP_DMA_MEM(&v->bitmap->plane[0][mod1l]));
               tmp[3].cp.inst.operand =
                       LOADDR(PREP_DMA_MEM(&v->bitmap->plane[0][mod1l]));
               if (depth == 2) {
                       tmp[4].cp.inst.operand =
                               HIADDR(PREP_DMA_MEM(&v->bitmap->plane[1][0]));
                       tmp[5].cp.inst.operand =
                               LOADDR(PREP_DMA_MEM(&v->bitmap->plane[1][0]));
                       tmp[6].cp.inst.operand =
                               HIADDR(PREP_DMA_MEM(&v->bitmap->plane[1][mod1l]));
                       tmp[7].cp.inst.operand =
                               LOADDR(PREP_DMA_MEM(&v->bitmap->plane[1][mod1l]));
               }
               /* set modulos. */
               tmp = find_copper_inst(cp, CI_MOVE(R_BPL1MOD));
               tmp[0].cp.inst.operand = mod2l + mod1l;
               tmp[1].cp.inst.operand = mod2l + mod1l;


               /* set next coper list pointers */
               tmp = find_copper_inst(cp, CI_MOVE(R_COP1LCH));
               tmp[0].cp.inst.operand =
                       HIADDR(PREP_DMA_MEM(hdl_this_data->frames[F_LACE_STORE_SHORT]));
               tmp[1].cp.inst.operand =
                       LOADDR(PREP_DMA_MEM(hdl_this_data->frames[F_LACE_STORE_SHORT]));

               bcopy(hdl_this_data->frames[F_LACE_STORE_LONG],
                       hdl_this_data->frames[F_LACE_STORE_SHORT],
                       std_dlace_copper_list_size);

               /* these are the only ones that are different from long frame. */
               cp = hdl_this_data->frames[F_LACE_STORE_SHORT];
               /* update plane pointers. */
               tmp = find_copper_inst(cp, CI_MOVE(R_BPL0PTH));
               tmp[0].cp.inst.operand =
                       HIADDR(PREP_DMA_MEM(&v->bitmap->plane[0][mod2l]));
               tmp[1].cp.inst.operand =
                       LOADDR(PREP_DMA_MEM(&v->bitmap->plane[0][mod2l]));
               tmp[2].cp.inst.operand =
                       HIADDR(PREP_DMA_MEM(&v->bitmap->plane[0][mod2l + mod1l]));
               tmp[3].cp.inst.operand =
                       LOADDR(PREP_DMA_MEM(&v->bitmap->plane[0][mod2l + mod1l]));
               if (depth == 2) {
                       tmp[4].cp.inst.operand =
                               HIADDR(PREP_DMA_MEM(&v->bitmap->plane[1][mod2l]));
                       tmp[5].cp.inst.operand =
                               LOADDR(PREP_DMA_MEM(&v->bitmap->plane[1][mod2l]));
                       tmp[6].cp.inst.operand =
                               HIADDR(PREP_DMA_MEM(&v->bitmap->plane[1][mod2l + mod1l]));
                       tmp[7].cp.inst.operand =
                               LOADDR(PREP_DMA_MEM(&v->bitmap->plane[1][mod2l + mod1l]));
               }
               /* set next copper list pointers */
               tmp = find_copper_inst(cp, CI_MOVE(R_COP1LCH));
               tmp[0].cp.inst.operand =
                       HIADDR(PREP_DMA_MEM(hdl_this_data->frames[F_LACE_STORE_LONG]));
               tmp[1].cp.inst.operand =
                       LOADDR(PREP_DMA_MEM(hdl_this_data->frames[F_LACE_STORE_LONG]));

               cp = hdl_this_data->frames[F_LACE_LONG];
               hdl_this_data->frames[F_LACE_LONG] =
                       hdl_this_data->frames[F_LACE_STORE_LONG];
               hdl_this_data->frames[F_LACE_STORE_LONG] = cp;

               cp = hdl_this_data->frames[F_LACE_SHORT];
               hdl_this_data->frames[F_LACE_SHORT] =
                       hdl_this_data->frames[F_LACE_STORE_SHORT];
               hdl_this_data->frames[F_LACE_STORE_SHORT] = cp;

               vd->flags |= VF_DISPLAY;
               cc_a2024_use_colormap(v, vd->colormap);
       }
       cc_load_mode(hdl_this);
}


dmode_t *
cc_init_ntsc_a2024(void)
{
       /* this function should only be called once. */
       if (!a24_this) {
               int     i;
               u_short len = std_a2024_copper_list_len;
               cop_t  *cp;

               a24_this = &a2024_mode;
               a24_this_data = &a2024_mode_data;
               memset(a24_this, 0, sizeof(dmode_t));
               memset(a24_this_data, 0, sizeof(dmdata_t));

               a24_this->name = "ntsc: A2024 15 kHz";
               a24_this->nominal_size.width = 1024;
               a24_this->nominal_size.height = 800;
               a24_this_data->max_size.width = 1024;
               a24_this_data->max_size.height = 800;
               a24_this_data->min_size.width = 1024;
               a24_this_data->min_size.height = 800;
               a24_this_data->min_depth = 1;
               a24_this_data->max_depth = 2;
               a24_this->data = a24_this_data;

               a24_this->get_monitor = cc_get_monitor;
               a24_this->alloc_view = cc_alloc_view;
               a24_this->get_current_view = cc_get_current_view;

               a24_this_data->use_colormap = cc_a2024_use_colormap;
               a24_this_data->get_colormap = cc_a2024_get_colormap;
               a24_this_data->display_view = display_a2024_view;
               a24_this_data->alloc_colormap = cc_a2024_alloc_colormap;
               a24_this_data->monitor = cc_monitor;

               a24_this_data->flags |= DMF_HEDLEY_EXP;

               a24_this_data->frames = a2024_frames;
               a24_this_data->frames[F_QD_QUAD0] =
                       alloc_chipmem(std_a2024_copper_list_size * F_QD_TOTAL);
               if (!a24_this_data->frames[F_QD_QUAD0]) {
                       panic("couldn't get chipmem for copper list");
               }
               /* setup the hedley init bitplane. */
               hedley_init = alloc_chipmem(128);
               if (!hedley_init) {
                       panic("couldn't get chipmem for hedley init bitplane");
               }
               for (i = 1; i < 128; i++)
                       hedley_init[i] = 0xff;
               hedley_init[0] = 0x03;

               /* copy image of standard copper list. */
               memcpy(a24_this_data->frames[0], std_a2024_copper_list,
                       std_a2024_copper_list_size);

               /* set the init plane pointer. */
               cp = find_copper_inst(a24_this_data->frames[F_QD_QUAD0],
                                       CI_MOVE(R_BPL0PTH));
               cp[0].cp.inst.operand = HIADDR(PREP_DMA_MEM(hedley_init));
               cp[1].cp.inst.operand = LOADDR(PREP_DMA_MEM(hedley_init));

               for (i = 1; i < F_QD_TOTAL; i++) {
                       a24_this_data->frames[i] = &a24_this_data->frames[i - 1][len];
                       bcopy(a24_this_data->frames[0],
                               a24_this_data->frames[i],
                               std_a2024_copper_list_size);
               }

               a24_this_data->bplcon0 = 0x8200;        /* hires */
               a24_this_data->vbl_handler =
                       (vbl_handler_func *) a2024_mode_vbl_handler;


               LIST_INSERT_HEAD(&MDATA(cc_monitor)->modes, a24_this, link);
       }
       return (a24_this);
}

void
display_a2024_view(view_t *v)
{
       if (a24_this_data->current_view != v) {
               vdata_t *vd = VDATA(v);
               cop_t  *cp, *tmp;
               u_char *inst_plane[2] = { NULL, NULL };
               u_char **plane = inst_plane;
               u_long  full_line = v->bitmap->bytes_per_row + v->bitmap->row_mod;
               u_long  half_plane = full_line * v->bitmap->rows / 2;

               int     depth = v->bitmap->depth, i, j;

               plane[0] = v->bitmap->plane[0];
               if (depth == 2) {
                       plane[1] = v->bitmap->plane[1];
               }
               if (a24_this_data->current_view) {
                       VDATA(a24_this_data->current_view)->flags &=
                               ~VF_DISPLAY;    /* mark as no longer displayed. */
               }
               cp = a24_this_data->frames[F_QD_STORE_QUAD0];
               tmp = find_copper_inst(cp, CI_MOVE(R_COLOR1F));
               tmp = find_copper_inst(tmp, CI_MOVE(R_BPLCON0)); /* grab third one. */
               tmp->cp.inst.operand = a24_this_data->bplcon0 |
                                       ((depth & 0x7) << 13);  /* times 2 */

               bcopy(a24_this_data->frames[F_QD_STORE_QUAD0],
                       a24_this_data->frames[F_QD_STORE_QUAD1],
                       std_a2024_copper_list_size);
               bcopy(a24_this_data->frames[F_QD_STORE_QUAD0],
                       a24_this_data->frames[F_QD_STORE_QUAD2],
                       std_a2024_copper_list_size);
               bcopy(a24_this_data->frames[F_QD_STORE_QUAD0],
                       a24_this_data->frames[F_QD_STORE_QUAD3],
                       std_a2024_copper_list_size);

               /*
                * Mark Id's
                */
               tmp = find_copper_inst(a24_this_data->frames[F_QD_STORE_QUAD1],
                       CI_WAIT(126, 21));
               CBUMP(tmp);
               CMOVE(tmp, R_COLOR01, QUAD1_ID);
               tmp = find_copper_inst(a24_this_data->frames[F_QD_STORE_QUAD2],
                       CI_WAIT(126, 21));
               CBUMP(tmp);
               CMOVE(tmp, R_COLOR01, QUAD2_ID);
               tmp = find_copper_inst(a24_this_data->frames[F_QD_STORE_QUAD3],
                       CI_WAIT(126, 21));
               CBUMP(tmp);
               CMOVE(tmp, R_COLOR01, QUAD3_ID);

               plane[0]--;
               plane[0]--;
               if (depth == 2) {
                       plane[1]--;
                       plane[1]--;
               }
               /*
                * Set bitplane pointers.
                */
               tmp = find_copper_inst(a24_this_data->frames[F_QD_STORE_QUAD0],
                       CI_MOVE(R_BPLMOD2));
               CBUMP(tmp);
               CMOVE(tmp, R_BPL0PTH, HIADDR(PREP_DMA_MEM(&plane[0][0])));
               CMOVE(tmp, R_BPL0PTL, LOADDR(PREP_DMA_MEM(&plane[0][0])));
               CMOVE(tmp, R_BPL1PTH, HIADDR(PREP_DMA_MEM(&plane[0][full_line])));
               CMOVE(tmp, R_BPL1PTL, LOADDR(PREP_DMA_MEM(&plane[0][full_line])));
               if (depth == 2) {
                       CMOVE(tmp, R_BPL2PTH, HIADDR(PREP_DMA_MEM(&plane[1][0])));
                       CMOVE(tmp, R_BPL2PTL, LOADDR(PREP_DMA_MEM(&plane[1][0])));
                       CMOVE(tmp, R_BPL3PTH, HIADDR(PREP_DMA_MEM(&plane[1][full_line])));
                       CMOVE(tmp, R_BPL3PTL, LOADDR(PREP_DMA_MEM(&plane[1][full_line])));
               }
#if defined (GRF_ECS) || defined (GRF_AGA)
               CMOVE(tmp, R_DIWHIGH, 0x2000);
#endif
               CMOVE(tmp, R_COP1LCH,
                       HIADDR(PREP_DMA_MEM(a24_this_data->frames[F_QD_STORE_QUAD1])));
               CMOVE(tmp, R_COP1LCL,
                       LOADDR(PREP_DMA_MEM(a24_this_data->frames[F_QD_STORE_QUAD1])));
               CEND(tmp);
               CEND(tmp);

               tmp = find_copper_inst(a24_this_data->frames[F_QD_STORE_QUAD1],
                                       CI_MOVE(R_BPLMOD2));
               CBUMP(tmp);
               CMOVE(tmp, R_BPL0PTH,
                       HIADDR(PREP_DMA_MEM(&plane[0][HALF_2024_LINE])));
               CMOVE(tmp, R_BPL0PTL,
                       LOADDR(PREP_DMA_MEM(&plane[0][HALF_2024_LINE])));
               CMOVE(tmp, R_BPL1PTH,
                       HIADDR(PREP_DMA_MEM(&plane[0][full_line + HALF_2024_LINE])));
               CMOVE(tmp, R_BPL1PTL,
                       LOADDR(PREP_DMA_MEM(&plane[0][full_line + HALF_2024_LINE])));
               if (depth == 2) {
                       CMOVE(tmp, R_BPL2PTH,
                               HIADDR(PREP_DMA_MEM(&plane[1][HALF_2024_LINE])));
                       CMOVE(tmp, R_BPL2PTL,
                               LOADDR(PREP_DMA_MEM(&plane[1][HALF_2024_LINE])));
                       CMOVE(tmp, R_BPL3PTH,
                               HIADDR(PREP_DMA_MEM(&plane[1][full_line + HALF_2024_LINE])));
                       CMOVE(tmp, R_BPL3PTL,
                               LOADDR(PREP_DMA_MEM(&plane[1][full_line + HALF_2024_LINE])));
               }
#if defined (GRF_ECS) || defined (GRF_AGA)
               CMOVE(tmp, R_DIWHIGH, 0x2000);
#endif
               CMOVE(tmp, R_COP1LCH,
                       HIADDR(PREP_DMA_MEM(a24_this_data->frames[F_QD_STORE_QUAD2])));
               CMOVE(tmp, R_COP1LCL,
                       LOADDR(PREP_DMA_MEM(a24_this_data->frames[F_QD_STORE_QUAD2])));
               CEND(tmp);
               CEND(tmp);

               tmp = find_copper_inst(a24_this_data->frames[F_QD_STORE_QUAD2],
                                       CI_MOVE(R_BPLMOD2));
               CBUMP(tmp);
               CMOVE(tmp, R_BPL0PTH,
                       HIADDR(PREP_DMA_MEM(&plane[0][half_plane])));
               CMOVE(tmp, R_BPL0PTL,
                       LOADDR(PREP_DMA_MEM(&plane[0][half_plane])));
               CMOVE(tmp, R_BPL1PTH,
                       HIADDR(PREP_DMA_MEM(&plane[0][half_plane + full_line])));
               CMOVE(tmp, R_BPL1PTL,
                       LOADDR(PREP_DMA_MEM(&plane[0][half_plane + full_line])));
               if (depth == 2) {
                       CMOVE(tmp, R_BPL2PTH,
                               HIADDR(PREP_DMA_MEM(&plane[1][half_plane])));
                       CMOVE(tmp, R_BPL2PTL,
                               LOADDR(PREP_DMA_MEM(&plane[1][half_plane])));
                       CMOVE(tmp, R_BPL3PTH,
                               HIADDR(PREP_DMA_MEM(&plane[1][half_plane + full_line])));
                       CMOVE(tmp, R_BPL3PTL,
                               LOADDR(PREP_DMA_MEM(&plane[1][half_plane + full_line])));
               }
#if defined (GRF_ECS) || defined (GRF_AGA)
               CMOVE(tmp, R_DIWHIGH, 0x2000);
#endif
               CMOVE(tmp, R_COP1LCH,
                       HIADDR(PREP_DMA_MEM(a24_this_data->frames[F_QD_STORE_QUAD3])));
               CMOVE(tmp, R_COP1LCL,
                       LOADDR(PREP_DMA_MEM(a24_this_data->frames[F_QD_STORE_QUAD3])));
               CEND(tmp);
               CEND(tmp);

               tmp = find_copper_inst(a24_this_data->frames[F_QD_STORE_QUAD3],
                                       CI_MOVE(R_BPLMOD2));
               CBUMP(tmp);
               CMOVE(tmp, R_BPL0PTH, HIADDR(PREP_DMA_MEM(
                       &plane[0][half_plane + HALF_2024_LINE])));
               CMOVE(tmp, R_BPL0PTL, LOADDR(PREP_DMA_MEM(
                       &plane[0][half_plane + HALF_2024_LINE])));
               CMOVE(tmp, R_BPL1PTH, HIADDR(PREP_DMA_MEM(
                       &plane[0][half_plane + full_line + HALF_2024_LINE])));
               CMOVE(tmp, R_BPL1PTL, LOADDR(PREP_DMA_MEM(
                       &plane[0][half_plane + full_line + HALF_2024_LINE])));
               if (depth == 2) {
                       CMOVE(tmp, R_BPL2PTH, HIADDR(PREP_DMA_MEM(
                               &plane[1][half_plane + HALF_2024_LINE])));
                       CMOVE(tmp, R_BPL2PTL, LOADDR(PREP_DMA_MEM(
                               &plane[1][half_plane + HALF_2024_LINE])));
                       CMOVE(tmp, R_BPL3PTH, HIADDR(PREP_DMA_MEM(
                               &plane[1][half_plane + full_line + HALF_2024_LINE])));
                       CMOVE(tmp, R_BPL3PTL, LOADDR(PREP_DMA_MEM(
                               &plane[1][half_plane + full_line + HALF_2024_LINE])));
               }
#if defined (GRF_ECS) || defined (GRF_AGA)
               CMOVE(tmp, R_DIWHIGH, 0x2000);
#endif
               CMOVE(tmp, R_COP1LCH, HIADDR(PREP_DMA_MEM(
                               a24_this_data->frames[F_QD_STORE_QUAD0])));
               CMOVE(tmp, R_COP1LCL, LOADDR(PREP_DMA_MEM(
                               a24_this_data->frames[F_QD_STORE_QUAD0])));
               CEND(tmp);
               CEND(tmp);

               /* swap new pointers in. */
               for (i = F_QD_STORE_QUAD0, j = F_QD_QUAD0;
                   i <= F_QD_STORE_QUAD3; i++, j++) {
                       cp = a24_this_data->frames[j];
                       a24_this_data->frames[j] = a24_this_data->frames[i];
                       a24_this_data->frames[i] = cp;
               }

               a24_this_data->current_view = v;
               vd->flags |= VF_DISPLAY;

               cc_a2024_use_colormap(v, vd->colormap);
       }
       cc_load_mode(a24_this);
}

void
a2024_mode_vbl_handler(dmode_t *d)
{
       u_short vp = ((custom.vposr & 0x0007) << 8) | ((custom.vhposr) >> 8);

       if (vp < 12) {
               custom.cop1lc =
                 PREP_DMA_MEM(a24_this_data->frames[a24_this_data->hedley_current]);
               custom.copjmp1 = 0;
       }
       a24_this_data->hedley_current++;
       a24_this_data->hedley_current &= 0x3;   /* if 4 then 0. */
}
#endif /* GRF_A2024 */

#if defined (GRF_AGA)

dmode_t *
cc_init_ntsc_aga(void)
{
       /* this function should only be called once. */
       if (!aga_this && (custom.deniseid & 0xff) == 0xf8 &&
           aga_enable & AGA_ENABLE) {
               u_short len = aga_copper_list_len;

               aga_this = &aga_mode;
               aga_this_data = &aga_mode_data;
               memset(aga_this, 0, sizeof(dmode_t));
               memset(aga_this_data, 0, sizeof(dmdata_t));

               aga_this->name = "ntsc: AGA dbl";
               aga_this->nominal_size.width = 640;
               aga_this->nominal_size.height = 400;
               aga_this_data->max_size.width = 724;
               aga_this_data->max_size.height = 482;
               aga_this_data->min_size.width = 320;
               aga_this_data->min_size.height = 200;
               aga_this_data->min_depth = 1;
               aga_this_data->max_depth = 8;
               aga_this->data = aga_this_data;

               aga_this->get_monitor = cc_get_monitor;
               aga_this->alloc_view = cc_alloc_view;
               aga_this->get_current_view = cc_get_current_view;

               aga_this_data->use_colormap = cc_use_aga_colormap;
               aga_this_data->get_colormap = cc_get_colormap;
               aga_this_data->alloc_colormap = cc_alloc_aga_colormap;
               aga_this_data->display_view = display_aga_view;
               aga_this_data->monitor = cc_monitor;

               aga_this_data->frames = aga_frames;
               aga_this_data->frames[F_LONG] = alloc_chipmem(aga_copper_list_size * F_TOTAL);
               if (!aga_this_data->frames[F_LONG]) {
                       panic("couldn't get chipmem for copper list");
               }
               aga_this_data->frames[F_STORE_LONG] = &aga_this_data->frames[F_LONG][len];

               memcpy(aga_this_data->frames[F_STORE_LONG], aga_copper_list, aga_copper_list_size);
               memcpy(aga_this_data->frames[F_LONG], aga_copper_list, aga_copper_list_size);

               aga_this_data->bplcon0 = 0x0240 | USE_CON3;     /* color composite
                                                                * enable,
                                                                * shres. */
#ifdef GRF_AGA_VGA
               aga_this_data->std_start_x = 0x40 /*STANDARD_VIEW_X*/;
#else
               aga_this_data->std_start_x = 0x4f /*STANDARD_VIEW_X*/;
#endif
               aga_this_data->std_start_y = 0x2b /*STANDARD_VIEW_Y*/;
               aga_this_data->vbl_handler = (vbl_handler_func *) cc_mode_vbl_handler;
               aga_this_data->beamcon0 = SPECIAL_BEAMCON ^ VSYNCTRUE;

               LIST_INSERT_HEAD(&MDATA(cc_monitor)->modes,
                   aga_this, link);
       }
       return (aga_this);
}

/* static, so I can patch and play */

#ifdef GRF_AGA_VGA
int     AGA_htotal = 0x71;
int     AGA_hsstrt = 0xc;
int     AGA_hsstop = 0x16;
int     AGA_hbstrt = 0x5;
int     AGA_vtotal = 0x1c1;
#else
int     AGA_htotal = 0x79;
int     AGA_hsstrt = 0xe;
int     AGA_hsstop = 0x1c;
int     AGA_hbstrt = 0x8;
int     AGA_vtotal = 0x1ec;
#endif
int     AGA_hbstop = 0x1e;
int     AGA_vsstrt = 0x3;
int     AGA_vsstop = 0x6;
int     AGA_vbstrt = 0x0;
int     AGA_vbstop = 0x19;
int     AGA_hcenter = 0x4a;

void
display_aga_view(view_t *v)
{
       if (aga_this_data->current_view != v) {
               vdata_t *vd = VDATA(v);
               cop_t  *cp = aga_this_data->frames[F_STORE_LONG], *tmp;
               int     depth = v->bitmap->depth, i;
               int     hstart, hstop, vstart, vstop, j;
               int     x, y, w = v->display.width, h = v->display.height;
               u_short ddfstart, ddfwidth, con1;

#ifdef DEBUG
               if (aga_enable & AGA_TRACE)
                       printf("display_aga_view(%dx%dx%d) %p\n", w, h,
                           depth, v);
#endif
               /* round down to nearest even width */
               /* w &= 0xfffe; */
               /* calculate datafetch width. */

               ddfwidth = ((v->bitmap->bytes_per_row >> 1) - 4) << 1;

               /* this will center the any overscanned display */
               /* and allow user to modify. */
               x = v->display.x + aga_this_data->std_start_x - ((w - 640) >> 3);
               y = v->display.y + aga_this_data->std_start_y - ((h - 400) >> 1);

               if (y & 1)
                       y--;

               if (!(x & 1))
                       x--;

               hstart = x;
               hstop = x + (w >> 2);
               vstart = y;
               vstop = y + (h >> 0);
               ddfstart = (hstart >> 1) - 8;

#ifdef DEBUG
               if (aga_enable & AGA_TRACE2) {
                       printf ("  ddfwidth %04x x %04x y %04x", ddfwidth,
                           x, y);
                       printf (" hstart %04x hstop %04x vstart %04x vstop %04x ddfstart %04x\n",
                           hstart, hstop, vstart, vstop, ddfstart);
               }
#endif
               /* check for hardware limits, AGA may allow more..? */
               /* anyone got a 4000 I can borrow :^) -ch */
               if ((ddfstart & 0xfffc) + ddfwidth > 0xd8) {
                       int     d = 0;

                       /* XXX anyone know the equality properties of
                        * intermixed logial AND's */
                       /* XXX and arithmetic operators? */
                       while (((ddfstart & 0xfffc) + ddfwidth - d) > 0xd8) {
                               d++;
                       }

                       ddfstart -= d;
                       hstart -= d << 1;
                       hstop -= d << 1;
               }
               /* correct the datafetch to proper limits. */
               /* delay the actual display of the data until we need it. */
               ddfstart &= 0xfffc;
#ifdef DEBUG
               if (aga_enable & AGA_TRACE2) {
                       printf ("  ddfwidth %04x x %04x y %04x", ddfwidth,
                           x, y);
                       printf (" hstart %04x hstop %04x vstart %04x vstop %04x ddfstart %04x\n",
                           hstart, hstop, vstart, vstop, ddfstart);
               }
#endif
               con1 = ((hstart - 9) - (ddfstart << 1)) | (((hstart - 9) - (ddfstart << 1)) << 4);

               if (aga_this_data->current_view) {
                       VDATA(aga_this_data->current_view)->flags &= ~VF_DISPLAY;       /* mark as no longer */
                       /* displayed. */
               }
               aga_this_data->current_view = v;

               cp = aga_this_data->frames[F_STORE_LONG];
               tmp = cp;
               for (i = 0; i < 8; ++i) {
                       if (tmp == NULL)
                               break;
                       tmp = find_copper_inst(tmp + 1, CI_MOVE(R_BPLCON3));
                       if (tmp == NULL)
                               break;
                       tmp->cp.inst.operand = 0x0ca1 | (i << 13);
                       tmp = find_copper_inst(tmp + 1, CI_MOVE(R_BPLCON3));
                       if (tmp == NULL)
                               break;
                       tmp->cp.inst.operand = 0x0ea1 | (i << 13);
               }
               if (tmp)
                       tmp = find_copper_inst(tmp + 1, CI_MOVE(R_BPLCON3));
               if (tmp)
                       tmp->cp.inst.operand = 0x0ca1;
               tmp = find_copper_inst(cp, CI_MOVE(R_FMODE));
               tmp->cp.inst.operand = 0x8003;
               tmp = find_copper_inst(cp, CI_MOVE(R_HTOTAL));
               tmp->cp.inst.operand = AGA_htotal; /* 81/71/73/79? */
               tmp = find_copper_inst(cp, CI_MOVE(R_HBSTRT));
               tmp->cp.inst.operand = AGA_hbstrt; /* 0x0008 */
               tmp = find_copper_inst(cp, CI_MOVE(R_HSSTRT));
               tmp->cp.inst.operand = AGA_hsstrt; /* 0x000e */
               tmp = find_copper_inst(cp, CI_MOVE(R_HSSTOP));
               tmp->cp.inst.operand = AGA_hsstop; /* 0x001c */
               tmp = find_copper_inst(cp, CI_MOVE(R_HBSTOP));
               tmp->cp.inst.operand = AGA_hsstop; /* 0x001e */
               tmp = find_copper_inst(cp, CI_MOVE(R_HCENTER));
               tmp->cp.inst.operand = AGA_hcenter; /*AGA_htotal / 2 + AGA_hsstrt */
               tmp = find_copper_inst(cp, CI_MOVE(R_VBSTRT));
               tmp->cp.inst.operand = AGA_vbstrt; /* 0x0000 */
               tmp = find_copper_inst(cp, CI_MOVE(R_VSSTRT));
               tmp->cp.inst.operand = AGA_vsstrt; /* 0x016b / AGA_htotal */
               tmp = find_copper_inst(cp, CI_MOVE(R_VSSTOP));
               tmp->cp.inst.operand = AGA_vsstop; /* 0x02d6 / AGA_htotal */
               tmp = find_copper_inst(cp, CI_MOVE(R_VBSTOP));
               tmp->cp.inst.operand = AGA_vbstop; /* 0x0bd1 / AGA_htotal */
               tmp = find_copper_inst(cp, CI_MOVE(R_VTOTAL));
               tmp->cp.inst.operand = AGA_vtotal;
               tmp = find_copper_inst(cp, CI_MOVE(R_BEAMCON0));
               tmp->cp.inst.operand = aga_this_data->beamcon0;
#ifdef DEBUG
               if (aga_enable & AGA_TRACE2)
                       printf("  beamcon0 %04x", tmp->cp.inst.operand);
#endif
               tmp = find_copper_inst(cp, CI_MOVE(R_DIWHIGH));
               tmp->cp.inst.operand = CALC_DIWHIGH(hstart, vstart, hstop, vstop);
#ifdef DEBUG
               if (aga_enable & AGA_TRACE2)
                       printf(" diwhigh %04x>", tmp->cp.inst.operand);
#endif
#if 0
               tmp->cp.inst.operand = (vstop & 0x0700) | ((hstop & 0x0100) << 5);
#endif
#ifdef DEBUG
               if (aga_enable & AGA_TRACE2)
                       printf("%04x", tmp->cp.inst.operand);
#endif
               tmp = find_copper_inst(cp, CI_MOVE(R_BPLCON0));
               tmp->cp.inst.operand = aga_this_data->bplcon0 |
                   ((depth & 0x7) << 12) | ((depth & 0x8) << 1);
#ifdef DEBUG
               if (aga_enable & AGA_TRACE2)
                       printf(" bplcon0 %04x", tmp->cp.inst.operand);
#endif
               tmp = find_copper_inst(cp, CI_MOVE(R_BPLCON1));
               tmp->cp.inst.operand = con1;
#ifdef DEBUG
               if (aga_enable & AGA_TRACE2)
                       printf(" bplcon1 %04x>0000\n", con1);
#endif
               tmp = find_copper_inst(cp, CI_MOVE(R_DIWSTART));
               tmp->cp.inst.operand = ((vstart & 0xff) << 8) | (hstart & 0xff);
#ifdef DEBUG
               if (aga_enable & AGA_TRACE2)
                       printf("  diwstart %04x", tmp->cp.inst.operand);
#endif
               tmp = find_copper_inst(cp, CI_MOVE(R_DIWSTOP));
               tmp->cp.inst.operand = ((vstop & 0xff) << 8) | (hstop & 0xff);
#ifdef DEBUG
               if (aga_enable & AGA_TRACE2)
                       printf(" diwstop %04x", tmp->cp.inst.operand);
#endif
               tmp = find_copper_inst(cp, CI_MOVE(R_DDFSTART));
               tmp->cp.inst.operand = ddfstart;
#ifdef DEBUG
               if (aga_enable & AGA_TRACE2)
                       printf(" ddfstart %04x", tmp->cp.inst.operand);
#endif
               tmp = find_copper_inst(cp, CI_MOVE(R_DDFSTOP));
               tmp->cp.inst.operand = ddfstart + ddfwidth;
#ifdef DEBUG
               if (aga_enable & AGA_TRACE2)
                       printf(" ddfstop %04x", tmp->cp.inst.operand);
#endif

               tmp = find_copper_inst(cp, CI_MOVE(R_BPL0PTH));
               for (i = 0, j = 0; i < depth; j += 2, i++) {
                       /* update the plane pointers */
                       tmp[j].cp.inst.operand = HIADDR(PREP_DMA_MEM(v->bitmap->plane[i]));
                       tmp[j + 1].cp.inst.operand = LOADDR(PREP_DMA_MEM(v->bitmap->plane[i]));
#ifdef DEBUG
               if (aga_enable & AGA_TRACE2)
                       printf (" bpl%dpth %p", i, v->bitmap->plane[i]);
#endif
               }

               /* set mods correctly. */
               tmp = find_copper_inst(cp, CI_MOVE(R_BPL1MOD));
               tmp[0].cp.inst.operand = v->bitmap->row_mod;
               tmp[1].cp.inst.operand = v->bitmap->row_mod;
#ifdef DEBUG
               if (aga_enable & AGA_TRACE2)
                       printf(" bplxmod %04x\n", v->bitmap->row_mod);
#endif

               /* set next pointers correctly */
               tmp = find_copper_inst(cp, CI_MOVE(R_COP1LCH));
               tmp[0].cp.inst.operand = HIADDR(PREP_DMA_MEM(aga_this_data->frames[F_STORE_LONG]));
               tmp[1].cp.inst.operand = LOADDR(PREP_DMA_MEM(aga_this_data->frames[F_STORE_LONG]));

               cp = aga_this_data->frames[F_LONG];
               aga_this_data->frames[F_LONG] = aga_this_data->frames[F_STORE_LONG];
               aga_this_data->frames[F_STORE_LONG] = cp;

               vd->flags |= VF_DISPLAY;

               cc_use_aga_colormap(v, vd->colormap);
       }
       cc_load_mode(aga_this);
#ifdef DEBUG
       if (aga_enable & AGA_TRACE)
               aga_enable |= AGA_TRACE2;       /* XXXX */
#endif
}

/*
* SUPER72 Mode
*/

#if defined (GRF_SUPER72)
dmode_t *
cc_init_super72(void)
{
       /* this function should only be called once. */
       if (!super72_this && (custom.deniseid & 0xff) == 0xf8) {
               u_short len = aga_copper_list_len;

               super72_this = &super72_mode;
               super72_this_data = &super72_mode_data;
               memset(super72_this, 0, sizeof(dmode_t));
               memset(super72_this_data, 0, sizeof(dmdata_t));

               super72_this->name = "super72: superhires interlace";
               super72_this->nominal_size.width = 800;
               super72_this->nominal_size.height = 600;
               super72_this_data->max_size.width = 848;
               super72_this_data->max_size.height = 614;
               super72_this_data->min_size.width = 320;
               super72_this_data->min_size.height = 484;
               super72_this_data->min_depth = 1;
               super72_this_data->max_depth = 8;
               super72_this->data = super72_this_data;

               super72_this->get_monitor = cc_get_monitor;
               super72_this->alloc_view = cc_alloc_view;
               super72_this->get_current_view = cc_get_current_view;

               super72_this_data->use_colormap = cc_use_aga_colormap;
               super72_this_data->get_colormap = cc_get_colormap;
               super72_this_data->alloc_colormap = cc_alloc_aga_colormap;
               super72_this_data->display_view = display_super72_view;
               super72_this_data->monitor = cc_monitor;

               super72_this_data->flags |= DMF_INTERLACE;

               super72_this_data->frames = super72_frames;     /* MAY NEED TO CHANGE COPLIST */
               super72_this_data->frames[F_LACE_LONG] =
                   alloc_chipmem(aga_copper_list_size * F_LACE_TOTAL);
               if (!super72_this_data->frames[F_LACE_LONG]) {
                       panic("couldn't get chipmem for copper list");
               }
               super72_this_data->frames[F_LACE_SHORT] =
                   &super72_this_data->frames[F_LACE_LONG][len];
               super72_this_data->frames[F_LACE_STORE_LONG] =
                   &super72_this_data->frames[F_LACE_SHORT][len];
               super72_this_data->frames[F_LACE_STORE_SHORT] =
                   &super72_this_data->frames[F_LACE_STORE_LONG][len];

               bcopy(aga_copper_list,
                   super72_this_data->frames[F_LACE_STORE_LONG],
                   aga_copper_list_size);
               bcopy(aga_copper_list,
                   super72_this_data->frames[F_LACE_STORE_SHORT],
                   aga_copper_list_size);
               bcopy(aga_copper_list,
                   super72_this_data->frames[F_LACE_LONG],
                   aga_copper_list_size);
               bcopy(aga_copper_list,
                   super72_this_data->frames[F_LACE_SHORT],
                   aga_copper_list_size);

               super72_this_data->bplcon0 = 0x0244 | USE_CON3; /* color
                                                                * composite enable,
                                                                * shres
                                                                * lace. */
#if 0   /* patchable variables for testing */
               super72_this_data->std_start_x = 0x6c;
               super72_this_data->std_start_y = 0x1b;
#endif
               super72_this_data->vbl_handler =
                   (vbl_handler_func *) cc_lace_mode_vbl_handler;
               super72_this_data->beamcon0 = (SPECIAL_BEAMCON ^ VSYNCTRUE) |
                   DISPLAYPAL | 0x4000;
               super72_this_data->beamcon0 = 0x5bb0;

               LIST_INSERT_HEAD(&MDATA(cc_monitor)->modes, super72_this, link);
       }
       return (super72_this);
}

/* Super72 83Hz hack monitor values */
/*int   super72_htotal = 0x083;
int     super72_hsstrt = 0x00d;
int     super72_hsstop = 0x01b;
int     super72_hbstrt = 0x001;
int     super72_hbstop = 0x021;
int     super72_vtotal = 0x148;
int     super72_vsstrt = 0x2d5;
int     super72_vsstop = 0x3ca;
int     super72_vbstrt = 0x000;
int     super72_vbstop = 0xfdc;
int     super72_hcenter = 0x04e;
*/

/* Super72 standard monitor values */
int     super72_htotal = 154;   /* 0x099*/
int     super72_hsstrt = 17;    /* 0x01c*/
int     super72_hsstop = 27;    /* 0x038*/
int     super72_hbstrt = 154;   /* 0x008*/
int     super72_hbstop = 55;    /* 0x01e*/
int     super72_vtotal = 328;   /* 0x147*/
int     super72_vsstrt = 11;    /* 0x030*/
int     super72_vsstop = 18;    /* 0x033*/
int     super72_vbstrt = 327;   /* 0x000*/
int     super72_vbstop = 27;    /* 0x019*/
int     super72_hcenter = 94;   /* 0x057*/
int     super72_startx = 100;
int     super72_starty = 27;

void
display_super72_view(view_t *v)
{
       if (super72_this_data->current_view != v) {
               vdata_t *vd = VDATA(v);
               cop_t  *cp = super72_this_data->frames[F_LACE_STORE_LONG], *tmp;
               int     depth = v->bitmap->depth, i;
               int     hstart, hstop, vstart, vstop, j;
               int     x, y, w = v->display.width, h = v->display.height;
               u_short ddfstart, ddfwidth, con1;

               /* round down to nearest even width */
               /* w &= 0xfffe; */

               /* calculate datafetch width. */
               ddfwidth = ((v->bitmap->bytes_per_row >> 1) - 4) << 1;

               /* This will center any overscanned display */
               /* and allow user to modify. */
               x = (v->display.x >> 1) + super72_startx - ((w - 800) >> 3);
               y = v->display.y + super72_starty - ((h - 600) >> 2);

               hstart = x;
               hstop = x + (w >> 2);
               vstart = y;
               vstop = y + (h >> 1);
               ddfstart = (hstart >> 1) - 16;

               ddfstart = (hstart << 2) - 4;
               con1 = ddfstart & 63;
               ddfstart = (ddfstart & -64) - 64;
               ddfwidth = ((w + 64 - 1) & -64) - 64;
               ddfwidth = ddfwidth >> 3;
               ddfstart = ddfstart >> 3;
               super72_hbstrt = ((x << 2) + w + 4) >> 3;
               super72_hbstop = (hstart + 1) >> 1;
               super72_vbstrt = vstop;
               super72_vbstop = vstart - 2;

               if ((hstop >> 1) > super72_htotal) {
                       int     d;

                       d = (hstop >> 1) - super72_htotal;
                       ddfstart -= d;
                       hstart -= d << 1;
                       hstop -= d << 1;
               }
               if (vstop >= super72_vtotal) {
                       int     d;
                       d = (vstop - super72_vtotal + 1);
                       vstart -= d;
                       vstop -= d;
               }
               con1 = ((con1 >> 2) & 0x000f) |         /* PF1H2-PF1H5 */
                      ((con1 << 8) & 0x0300) |         /* PF1H0-PF1H2 */
                      ((con1 << 4) & 0x0c00);          /* PF1H6-PF1H7 */
               con1 |= con1 << 4;                      /* PF2H2-PF2H7 */

               if (super72_this_data->current_view) {
                       VDATA(super72_this_data->current_view)->flags &=
                           ~VF_DISPLAY;        /* mark as no longer */
                                               /* displayed. */
               }
               super72_this_data->current_view = v;

               cp = super72_this_data->frames[F_LACE_STORE_LONG];
               tmp = find_copper_inst(cp, CI_MOVE(R_FMODE));
               tmp->cp.inst.operand = 0x8003;
               tmp = find_copper_inst(cp, CI_MOVE(R_HTOTAL));
               tmp->cp.inst.operand = super72_htotal;
               tmp = find_copper_inst(cp, CI_MOVE(R_HBSTRT));
               tmp->cp.inst.operand = super72_hbstrt;
               tmp = find_copper_inst(cp, CI_MOVE(R_HSSTRT));
               tmp->cp.inst.operand = super72_hsstrt;
               tmp = find_copper_inst(cp, CI_MOVE(R_HSSTOP));
               tmp->cp.inst.operand = super72_hsstop;
               tmp = find_copper_inst(cp, CI_MOVE(R_HBSTOP));
               tmp->cp.inst.operand = super72_hbstop;
               tmp = find_copper_inst(cp, CI_MOVE(R_HCENTER));
               tmp->cp.inst.operand = super72_hcenter;
               tmp = find_copper_inst(cp, CI_MOVE(R_VBSTRT));
               tmp->cp.inst.operand = super72_vbstrt;
               tmp = find_copper_inst(cp, CI_MOVE(R_VSSTRT));
               tmp->cp.inst.operand = super72_vsstrt;
               tmp = find_copper_inst(cp, CI_MOVE(R_VSSTOP));
               tmp->cp.inst.operand = super72_vsstop;
               tmp = find_copper_inst(cp, CI_MOVE(R_VBSTOP));
               tmp->cp.inst.operand = super72_vbstop;
               tmp = find_copper_inst(cp, CI_MOVE(R_VTOTAL));
               tmp->cp.inst.operand = super72_vtotal;

               tmp = find_copper_inst(cp, CI_MOVE(R_BEAMCON0));
               tmp->cp.inst.operand = super72_this_data->beamcon0;
               tmp = find_copper_inst(cp, CI_MOVE(R_DIWHIGH));
               tmp->cp.inst.operand =
                   CALC_DIWHIGH(hstart, vstart, hstop, vstop);
               tmp = find_copper_inst(cp, CI_MOVE(R_BPLCON0));
               tmp->cp.inst.operand = super72_this_data->bplcon0 |
                   ((depth & 0x7) << 12) | ((depth & 0x8) << 1);
               tmp = find_copper_inst(cp, CI_MOVE(R_BPLCON1));
               tmp->cp.inst.operand = con1;
               tmp = find_copper_inst(cp, CI_MOVE(R_DIWSTART));
               tmp->cp.inst.operand = ((vstart & 0xff) << 8) | (hstart & 0xff);
               tmp = find_copper_inst(cp, CI_MOVE(R_DIWSTOP));
               tmp->cp.inst.operand = ((vstop & 0xff) << 8) | (hstop & 0xff);
               tmp = find_copper_inst(cp, CI_MOVE(R_DDFSTART));
               tmp->cp.inst.operand = ddfstart;
               tmp = find_copper_inst(cp, CI_MOVE(R_DDFSTOP));
               tmp->cp.inst.operand = ddfstart + ddfwidth;

               tmp = find_copper_inst(cp, CI_MOVE(R_BPL0PTH));
               for (i = 0, j = 0; i < depth; j += 2, i++) {
                       /* update the plane pointers */
                       tmp[j].cp.inst.operand =
                           HIADDR(PREP_DMA_MEM(v->bitmap->plane[i]));
                       tmp[j + 1].cp.inst.operand =
                           LOADDR(PREP_DMA_MEM(v->bitmap->plane[i]));
               }

               /* set mods correctly. */
               tmp = find_copper_inst(cp, CI_MOVE(R_BPL1MOD));
               tmp[0].cp.inst.operand = v->bitmap->bytes_per_row +
                   v->bitmap->row_mod;
               tmp[1].cp.inst.operand = v->bitmap->bytes_per_row +
                   v->bitmap->row_mod;

               /* set next pointers correctly */
               tmp = find_copper_inst(cp, CI_MOVE(R_COP1LCH));
               tmp[0].cp.inst.operand =
                   HIADDR(PREP_DMA_MEM(super72_this_data->frames[F_LACE_STORE_SHORT]));
               tmp[1].cp.inst.operand =
                   LOADDR(PREP_DMA_MEM(super72_this_data->frames[F_LACE_STORE_SHORT]));

               bcopy(super72_this_data->frames[F_LACE_STORE_LONG],
                   super72_this_data->frames[F_LACE_STORE_SHORT],
                   aga_copper_list_size);

               /* these are the only ones that are different from long frame. */
               cp = super72_this_data->frames[F_LACE_STORE_SHORT];
               tmp = find_copper_inst(cp, CI_MOVE(R_BPL0PTH));
               for (i = 0, j = 0; i < depth; j += 2, i++) {
                       u_short mod = v->bitmap->bytes_per_row +
                           v->bitmap->row_mod;
                       /* update plane pointers. high and low. */
                       tmp[j].cp.inst.operand =
                           HIADDR(PREP_DMA_MEM(&v->bitmap->plane[i][mod]));
                       tmp[j + 1].cp.inst.operand =
                           LOADDR(PREP_DMA_MEM(&v->bitmap->plane[i][mod]));
               }

               /* set next pointers correctly */
               tmp = find_copper_inst(cp, CI_MOVE(R_COP1LCH));
               tmp[0].cp.inst.operand =
                   HIADDR(PREP_DMA_MEM(super72_this_data->frames[F_LACE_STORE_LONG]));
               tmp[1].cp.inst.operand =
                    LOADDR(PREP_DMA_MEM(super72_this_data->frames[F_LACE_STORE_LONG]));

               cp = super72_this_data->frames[F_LACE_LONG];
               super72_this_data->frames[F_LACE_LONG] =
                   super72_this_data->frames[F_LACE_STORE_LONG];
               super72_this_data->frames[F_LACE_STORE_LONG] = cp;

               cp = super72_this_data->frames[F_LACE_SHORT];
               super72_this_data->frames[F_LACE_SHORT] =
                   super72_this_data->frames[F_LACE_STORE_SHORT];
               super72_this_data->frames[F_LACE_STORE_SHORT] = cp;

               vd->flags |= VF_DISPLAY;
               cc_use_aga_colormap(v, vd->colormap);
       }
       cc_load_mode(super72_this);
}
#endif /* GRF_SUPER72 */

#endif /* GRF_AGA */
#endif /* GRF_NTSC */

/*
* PAL modes.
*/

#if defined (GRF_PAL)

dmode_t *
cc_init_pal_hires(void)
{
       /* this function should only be called once. */
       if (!ph_this) {
               u_short len = std_copper_list_len;

               ph_this = &pal_hires_mode;
               ph_this_data = &pal_hires_mode_data;
               memset(ph_this, 0, sizeof(dmode_t));
               memset(ph_this_data, 0, sizeof(dmdata_t));

               ph_this->name = "pal: hires";
               ph_this->nominal_size.width = 640;
               ph_this->nominal_size.height = 256;
               ph_this_data->max_size.width = 724;
               ph_this_data->max_size.height = 289;
               ph_this_data->min_size.width = 320;
               ph_this_data->min_size.height = 244;
               ph_this_data->min_depth = 1;
               ph_this_data->max_depth = 4;
               ph_this->data = ph_this_data;

               ph_this->get_monitor = cc_get_monitor;
               ph_this->alloc_view = cc_alloc_view;
               ph_this->get_current_view = cc_get_current_view;

               ph_this_data->use_colormap = cc_use_colormap;
               ph_this_data->get_colormap = cc_get_colormap;
               ph_this_data->alloc_colormap = cc_alloc_colormap;
               ph_this_data->display_view = display_pal_hires_view;
               ph_this_data->monitor = cc_monitor;

               ph_this_data->frames = pal_hires_frames;
               ph_this_data->frames[F_LONG] = alloc_chipmem(std_copper_list_size * F_TOTAL);
               if (!ph_this_data->frames[F_LONG]) {
                       panic("couldn't get chipmem for copper list");
               }
               ph_this_data->frames[F_STORE_LONG] = &ph_this_data->frames[F_LONG][len];

               memcpy(ph_this_data->frames[F_STORE_LONG], std_copper_list, std_copper_list_size);
               memcpy(ph_this_data->frames[F_LONG], std_copper_list, std_copper_list_size);

               ph_this_data->bplcon0 = 0x8200 | USE_CON3;      /* pal_hires, color
                                                                * composite enable,
                                                                * lace. */
               ph_this_data->std_start_x = STANDARD_VIEW_X;
               ph_this_data->std_start_y = STANDARD_VIEW_Y;
               ph_this_data->vbl_handler = (vbl_handler_func *) cc_mode_vbl_handler;
#if defined (GRF_ECS) || defined (GRF_AGA)
               ph_this_data->beamcon0 = STANDARD_PAL_BEAMCON;
#endif

               LIST_INSERT_HEAD(&MDATA(cc_monitor)->modes, ph_this, link);
       }
       return (ph_this);
}

void
display_pal_hires_view(view_t *v)
{
       if (ph_this_data->current_view != v) {
               vdata_t *vd = VDATA(v);
               cop_t  *cp = ph_this_data->frames[F_STORE_LONG], *tmp;
               int     depth = v->bitmap->depth, i;
               int     hstart, hstop, vstart, vstop, j;
               int     x, y, w = v->display.width, h = v->display.height;
               u_short ddfstart, ddfwidth, con1;

               /* round down to nearest even width */
               /* w &= 0xfffe; */

               /* calculate datafetch width. */
               ddfwidth = ((v->bitmap->bytes_per_row >> 1) - 2) << 2;

               /* This will center the any overscanned display */
               /* and allow user to modify. */
               x = v->display.x + ph_this_data->std_start_x - ((w - 640) >> 2);
               y = v->display.y + ph_this_data->std_start_y - ((h - 256) >> 1);

               if (y & 1)
                       y--;

               if (!(x & 1))
                       x--;

               hstart = x;
               hstop = x + (w >> 1);
               vstart = y;
               vstop = y + h;
               ddfstart = (hstart - 9) >> 1;
               /* check for hardware limits, AGA may allow more..? */
               /* anyone got a 4000 I can borrow :^) -ch */
               if ((ddfstart & 0xfffc) + ddfwidth > 0xd8) {
                       int     d = 0;

                       /* XXX anyone know the equality properties of
                        * intermixed logial AND's */
                       /* XXX and arithmetic operators? */
                       while (((ddfstart & 0xfffc) + ddfwidth - d) > 0xd8) {
                               d++;
                       }

                       ddfstart -= d;
                       hstart -= d << 1;
                       hstop -= d << 1;
               }
               /* correct the datafetch to proper limits. */
               /* delay the actual display of the data until we need it. */
               ddfstart &= 0xfffc;
               con1 = ((hstart - 9) - (ddfstart << 1)) | (((hstart - 9) - (ddfstart << 1)) << 4);

               if (ph_this_data->current_view) {
                       VDATA(ph_this_data->current_view)->flags &= ~VF_DISPLAY;        /* mark as no longer */
                       /* displayed. */
               }
               ph_this_data->current_view = v;

               cp = ph_this_data->frames[F_STORE_LONG];
#if defined (GRF_ECS) || defined (GRF_AGA)
#if defined (GRF_AGA)
               tmp = find_copper_inst(cp, CI_MOVE(R_FMODE));
               tmp->cp.inst.operand = 0;
#endif
               tmp = find_copper_inst(cp, CI_MOVE(R_BEAMCON0));
               tmp->cp.inst.operand = ph_this_data->beamcon0;
               tmp = find_copper_inst(cp, CI_MOVE(R_DIWHIGH));
               tmp->cp.inst.operand = CALC_DIWHIGH(hstart, vstart, hstop, vstop);
#endif /* ECS */
               tmp = find_copper_inst(cp, CI_MOVE(R_BPLCON0));
               tmp->cp.inst.operand = ph_this_data->bplcon0 | ((depth & 0x7) << 12);
               tmp = find_copper_inst(cp, CI_MOVE(R_BPLCON1));
               tmp->cp.inst.operand = con1;
               tmp = find_copper_inst(cp, CI_MOVE(R_DIWSTART));
               tmp->cp.inst.operand = ((vstart & 0xff) << 8) | (hstart & 0xff);
               tmp = find_copper_inst(cp, CI_MOVE(R_DIWSTOP));
               tmp->cp.inst.operand = ((vstop & 0xff) << 8) | (hstop & 0xff);
               tmp = find_copper_inst(cp, CI_MOVE(R_DDFSTART));
               tmp->cp.inst.operand = ddfstart;
               tmp = find_copper_inst(cp, CI_MOVE(R_DDFSTOP));
               tmp->cp.inst.operand = ddfstart + ddfwidth;

               tmp = find_copper_inst(cp, CI_MOVE(R_BPL0PTH));
               for (i = 0, j = 0; i < depth; j += 2, i++) {
                       /* update the plane pointers */
                       tmp[j].cp.inst.operand = HIADDR(PREP_DMA_MEM(v->bitmap->plane[i]));
                       tmp[j + 1].cp.inst.operand = LOADDR(PREP_DMA_MEM(v->bitmap->plane[i]));
               }

               /* set mods correctly. */
               tmp = find_copper_inst(cp, CI_MOVE(R_BPL1MOD));
               tmp[0].cp.inst.operand = v->bitmap->row_mod;
               tmp[1].cp.inst.operand = v->bitmap->row_mod;

               /* set next pointers correctly */
               tmp = find_copper_inst(cp, CI_MOVE(R_COP1LCH));
               tmp[0].cp.inst.operand = HIADDR(PREP_DMA_MEM(ph_this_data->frames[F_STORE_LONG]));
               tmp[1].cp.inst.operand = LOADDR(PREP_DMA_MEM(ph_this_data->frames[F_STORE_LONG]));

               cp = ph_this_data->frames[F_LONG];
               ph_this_data->frames[F_LONG] = ph_this_data->frames[F_STORE_LONG];
               ph_this_data->frames[F_STORE_LONG] = cp;

               vd->flags |= VF_DISPLAY;
               cc_use_colormap(v, vd->colormap);
       }
       cc_load_mode(ph_this);
}

dmode_t *
cc_init_pal_hires_lace(void)
{
       /* this function should only be called once. */
       if (!phl_this) {
               u_short len = std_copper_list_len;

               phl_this = &pal_hires_lace_mode;
               phl_this_data = &pal_hires_lace_mode_data;
               memset(phl_this, 0, sizeof(dmode_t));
               memset(phl_this_data, 0, sizeof(dmdata_t));

               phl_this->name = "pal: hires interlace";
               phl_this->nominal_size.width = 640;
               phl_this->nominal_size.height = 512;
               phl_this_data->max_size.width = 724;
               phl_this_data->max_size.height = 578;
               phl_this_data->min_size.width = 320;
               phl_this_data->min_size.height = 484;
               phl_this_data->min_depth = 1;
               phl_this_data->max_depth = 4;
               phl_this->data = phl_this_data;

               phl_this->get_monitor = cc_get_monitor;
               phl_this->alloc_view = cc_alloc_view;
               phl_this->get_current_view = cc_get_current_view;

               phl_this_data->use_colormap = cc_use_colormap;
               phl_this_data->get_colormap = cc_get_colormap;
               phl_this_data->alloc_colormap = cc_alloc_colormap;
               phl_this_data->display_view = display_pal_hires_lace_view;
               phl_this_data->monitor = cc_monitor;

               phl_this_data->flags |= DMF_INTERLACE;

               phl_this_data->frames = pal_hires_lace_frames;
               phl_this_data->frames[F_LACE_LONG] = alloc_chipmem(std_copper_list_size * F_LACE_TOTAL);
               if (!phl_this_data->frames[F_LACE_LONG]) {
                       panic("couldn't get chipmem for copper list");
               }
               phl_this_data->frames[F_LACE_SHORT] = &phl_this_data->frames[F_LACE_LONG][len];
               phl_this_data->frames[F_LACE_STORE_LONG] = &phl_this_data->frames[F_LACE_SHORT][len];
               phl_this_data->frames[F_LACE_STORE_SHORT] = &phl_this_data->frames[F_LACE_STORE_LONG][len];

               memcpy(phl_this_data->frames[F_LACE_STORE_LONG], std_copper_list, std_copper_list_size);
               memcpy(phl_this_data->frames[F_LACE_STORE_SHORT], std_copper_list, std_copper_list_size);
               memcpy(phl_this_data->frames[F_LACE_LONG], std_copper_list, std_copper_list_size);
               memcpy(phl_this_data->frames[F_LACE_SHORT], std_copper_list, std_copper_list_size);

               phl_this_data->bplcon0 = 0x8204 | USE_CON3;     /* hires, color
                                                                * composite enable,
                                                                * lace. */
               phl_this_data->std_start_x = STANDARD_VIEW_X;
               phl_this_data->std_start_y = STANDARD_VIEW_Y;
               phl_this_data->vbl_handler = (vbl_handler_func *) cc_lace_mode_vbl_handler;
#if defined (GRF_ECS) || defined (GRF_AGA)
               phl_this_data->beamcon0 = STANDARD_PAL_BEAMCON;
#endif

               LIST_INSERT_HEAD(&MDATA(cc_monitor)->modes, phl_this, link);
       }
       return (phl_this);
}

void
display_pal_hires_lace_view(view_t *v)
{
       if (phl_this_data->current_view != v) {
               vdata_t *vd = VDATA(v);
               cop_t  *cp = phl_this_data->frames[F_LACE_STORE_LONG], *tmp;
               int     depth = v->bitmap->depth, i;
               int     hstart, hstop, vstart, vstop, j;
               int     x, y, w = v->display.width, h = v->display.height;
               u_short ddfstart, ddfwidth, con1;

               /* round down to nearest even width */
               /* w &= 0xfffe; */

               /* calculate datafetch width. */
               ddfwidth = ((v->bitmap->bytes_per_row >> 1) - 2) << 2;

               /* This will center the any overscanned display */
               /* and allow user to modify. */
               x = v->display.x + phl_this_data->std_start_x - ((w - 640) >> 2);
               y = v->display.y + phl_this_data->std_start_y - ((h - 512) >> 2);

               if (y & 1)
                       y--;

               if (!(x & 1))
                       x--;

               hstart = x;
               hstop = x + (w >> 1);
               vstart = y;
               vstop = y + (h >> 1);
               ddfstart = (hstart - 9) >> 1;

               /* check for hardware limits, AGA may allow more..? */
               /* anyone got a 4000 I can borrow :^) -ch */
               if ((ddfstart & 0xfffc) + ddfwidth > 0xd8) {
                       int     d = 0;

                       /* XXX anyone know the equality properties of
                        * intermixed logial AND's */
                       /* XXX and arithmetic operators? */
                       while (((ddfstart & 0xfffc) + ddfwidth - d) > 0xd8) {
                               d++;
                       }

                       ddfstart -= d;
                       hstart -= d << 1;
                       hstop -= d << 1;
               }
               /* correct the datafetch to proper limits. */
               /* delay the actual display of the data until we need it. */
               ddfstart &= 0xfffc;
               con1 = ((hstart - 9) - (ddfstart << 1)) | (((hstart - 9) - (ddfstart << 1)) << 4);

               if (phl_this_data->current_view) {
                       VDATA(phl_this_data->current_view)->flags &= ~VF_DISPLAY;       /* mark as no longer */
                       /* displayed. */
               }
               phl_this_data->current_view = v;

               cp = phl_this_data->frames[F_LACE_STORE_LONG];
#if defined (GRF_ECS) || defined (GRF_AGA)
#if defined (GRF_AGA)
               tmp = find_copper_inst(cp, CI_MOVE(R_FMODE));
               tmp->cp.inst.operand = 0;
#endif
               tmp = find_copper_inst(cp, CI_MOVE(R_BEAMCON0));
               tmp->cp.inst.operand = phl_this_data->beamcon0;
               tmp = find_copper_inst(cp, CI_MOVE(R_DIWHIGH));
               tmp->cp.inst.operand = CALC_DIWHIGH(hstart, vstart, hstop, vstop);
#endif /* ECS */
               tmp = find_copper_inst(cp, CI_MOVE(R_BPLCON0));
               tmp->cp.inst.operand = phl_this_data->bplcon0 | ((depth & 0x7) << 12);
               tmp = find_copper_inst(cp, CI_MOVE(R_BPLCON1));
               tmp->cp.inst.operand = con1;
               tmp = find_copper_inst(cp, CI_MOVE(R_DIWSTART));
               tmp->cp.inst.operand = ((vstart & 0xff) << 8) | (hstart & 0xff);
               tmp = find_copper_inst(cp, CI_MOVE(R_DIWSTOP));
               tmp->cp.inst.operand = ((vstop & 0xff) << 8) | (hstop & 0xff);
               tmp = find_copper_inst(cp, CI_MOVE(R_DDFSTART));
               tmp->cp.inst.operand = ddfstart;
               tmp = find_copper_inst(cp, CI_MOVE(R_DDFSTOP));
               tmp->cp.inst.operand = ddfstart + ddfwidth;

               tmp = find_copper_inst(cp, CI_MOVE(R_BPL0PTH));
               for (i = 0, j = 0; i < depth; j += 2, i++) {
                       /* update the plane pointers */
                       tmp[j].cp.inst.operand = HIADDR(PREP_DMA_MEM(v->bitmap->plane[i]));
                       tmp[j + 1].cp.inst.operand = LOADDR(PREP_DMA_MEM(v->bitmap->plane[i]));
               }

               /* set mods correctly. */
               tmp = find_copper_inst(cp, CI_MOVE(R_BPL1MOD));
               tmp[0].cp.inst.operand = v->bitmap->bytes_per_row + v->bitmap->row_mod;
               tmp[1].cp.inst.operand = v->bitmap->bytes_per_row + v->bitmap->row_mod;

               /* set next pointers correctly */
               tmp = find_copper_inst(cp, CI_MOVE(R_COP1LCH));
               tmp[0].cp.inst.operand = HIADDR(PREP_DMA_MEM(phl_this_data->frames[F_LACE_STORE_SHORT]));
               tmp[1].cp.inst.operand = LOADDR(PREP_DMA_MEM(phl_this_data->frames[F_LACE_STORE_SHORT]));


               memcpy(phl_this_data->frames[F_LACE_STORE_SHORT], phl_this_data->frames[F_LACE_STORE_LONG], std_copper_list_size);

               /* these are the only ones that are different from long frame. */
               cp = phl_this_data->frames[F_LACE_STORE_SHORT];
               tmp = find_copper_inst(cp, CI_MOVE(R_BPL0PTH));
               for (i = 0, j = 0; i < depth; j += 2, i++) {
                       u_short mod = v->bitmap->bytes_per_row + v->bitmap->row_mod;
                       /* update plane pointers. high and low. */
                       tmp[j].cp.inst.operand = HIADDR(PREP_DMA_MEM(&v->bitmap->plane[i][mod]));
                       tmp[j + 1].cp.inst.operand = LOADDR(PREP_DMA_MEM(&v->bitmap->plane[i][mod]));
               }

               /* set next pointers correctly */
               tmp = find_copper_inst(cp, CI_MOVE(R_COP1LCH));
               tmp[0].cp.inst.operand = HIADDR(PREP_DMA_MEM(phl_this_data->frames[F_LACE_STORE_LONG]));
               tmp[1].cp.inst.operand = LOADDR(PREP_DMA_MEM(phl_this_data->frames[F_LACE_STORE_LONG]));


               cp = phl_this_data->frames[F_LACE_LONG];
               phl_this_data->frames[F_LACE_LONG] = phl_this_data->frames[F_LACE_STORE_LONG];
               phl_this_data->frames[F_LACE_STORE_LONG] = cp;

               cp = phl_this_data->frames[F_LACE_SHORT];
               phl_this_data->frames[F_LACE_SHORT] = phl_this_data->frames[F_LACE_STORE_SHORT];
               phl_this_data->frames[F_LACE_STORE_SHORT] = cp;

               vd->flags |= VF_DISPLAY;
               cc_use_colormap(v, vd->colormap);
       }
       cc_load_mode(phl_this);
}
#if defined (GRF_A2024)

dmode_t *
cc_init_pal_hires_dlace(void)
{
       /* this function should only be called once. */
       if (!phdl_this) {
               u_short len = std_dlace_copper_list_len;

               phdl_this = &pal_hires_dlace_mode;
               phdl_this_data = &pal_hires_dlace_mode_data;
               memset(phdl_this, 0, sizeof(dmode_t));
               memset(phdl_this_data, 0, sizeof(dmdata_t));

               phdl_this->name = "pal: hires double interlace";
               phdl_this->nominal_size.width = 640;
               phdl_this->nominal_size.height = 1024;
               phdl_this_data->max_size.width = 724;
               phdl_this_data->max_size.height = 1024;
               phdl_this_data->min_size.width = 320;
               phdl_this_data->min_size.height = 512;
               phdl_this_data->min_depth = 1;
               phdl_this_data->max_depth = 2;
               phdl_this->data = phdl_this_data;

               phdl_this->get_monitor = cc_get_monitor;
               phdl_this->alloc_view = cc_alloc_view;
               phdl_this->get_current_view = cc_get_current_view;

               phdl_this_data->use_colormap = cc_a2024_use_colormap;
               phdl_this_data->get_colormap = cc_a2024_get_colormap;
               phdl_this_data->alloc_colormap = cc_a2024_alloc_colormap;
               phdl_this_data->display_view = display_pal_hires_dlace_view;
               phdl_this_data->monitor = cc_monitor;

               phdl_this_data->flags |= DMF_INTERLACE;

               phdl_this_data->frames = pal_hires_dlace_frames;
               phdl_this_data->frames[F_LACE_LONG] = alloc_chipmem(std_dlace_copper_list_size * F_LACE_TOTAL);
               if (!phdl_this_data->frames[F_LACE_LONG]) {
                       panic("couldn't get chipmem for copper list");
               }
               phdl_this_data->frames[F_LACE_SHORT] = &phdl_this_data->frames[F_LACE_LONG][len];
               phdl_this_data->frames[F_LACE_STORE_LONG] = &phdl_this_data->frames[F_LACE_SHORT][len];
               phdl_this_data->frames[F_LACE_STORE_SHORT] = &phdl_this_data->frames[F_LACE_STORE_LONG][len];

               memcpy(phdl_this_data->frames[F_LACE_STORE_LONG], std_dlace_copper_list, std_dlace_copper_list_size);
               memcpy(phdl_this_data->frames[F_LACE_STORE_SHORT], std_dlace_copper_list, std_dlace_copper_list_size);
               memcpy(phdl_this_data->frames[F_LACE_LONG], std_dlace_copper_list, std_dlace_copper_list_size);
               memcpy(phdl_this_data->frames[F_LACE_SHORT], std_dlace_copper_list, std_dlace_copper_list_size);

               phdl_this_data->bplcon0 = 0x8204 | USE_CON3;    /* hires, color
                                                                * composite enable,
                                                                * dlace. */
               phdl_this_data->std_start_x = STANDARD_VIEW_X;
               phdl_this_data->std_start_y = STANDARD_VIEW_Y;
               phdl_this_data->vbl_handler = (vbl_handler_func *) cc_lace_mode_vbl_handler;
#if defined (GRF_ECS) || defined (GRF_AGA)
               phdl_this_data->beamcon0 = STANDARD_PAL_BEAMCON;
#endif

               LIST_INSERT_HEAD(&MDATA(cc_monitor)->modes, phdl_this, link);
       }
       return (phdl_this);
}

void
display_pal_hires_dlace_view(view_t *v)
{
       if (phdl_this_data->current_view != v) {
               vdata_t *vd = VDATA(v);
               cop_t  *cp = phdl_this_data->frames[F_LACE_STORE_LONG], *tmp;
               int     depth = v->bitmap->depth;
               int     hstart, hstop, vstart, vstop;
               int     x, y, w = v->display.width, h = v->display.height;
               u_short ddfstart, ddfwidth, con1;
               u_short mod1l, mod2l;

               /* round down to nearest even width */
               /* w &= 0xfffe; */

               /* calculate datafetch width. */
               ddfwidth = ((v->bitmap->bytes_per_row >> 1) - 2) << 2;

               /* This will center the any overscanned display */
               /* and allow user to modify. */
               x = v->display.x + phdl_this_data->std_start_x - ((w - 640) >> 2);
               y = v->display.y + phdl_this_data->std_start_y - ((h - 1024) >> 3);

               if (y & 1)
                       y--;

               if (!(x & 1))
                       x--;

               hstart = x;
               hstop = x + (w >> 1);
               vstart = y;
               vstop = y + (h >> 2);
               ddfstart = (hstart - 9) >> 1;

               /* check for hardware limits, AGA may allow more..? */
               /* anyone got a 4000 I can borrow :^) -ch */
               if ((ddfstart & 0xfffc) + ddfwidth > 0xd8) {
                       int     d = 0;

                       /* XXX anyone know the equality properties of
                        * intermixed logial AND's */
                       /* XXX and arithmetic operators? */
                       while (((ddfstart & 0xfffc) + ddfwidth - d) > 0xd8) {
                               d++;
                       }

                       ddfstart -= d;
                       hstart -= d << 1;
                       hstop -= d << 1;
               }
               /* correct the datafetch to proper limits. */
               /* delay the actual display of the data until we need it. */
               ddfstart &= 0xfffc;
               con1 = ((hstart - 9) - (ddfstart << 1)) | (((hstart - 9) - (ddfstart << 1)) << 4);

               if (phdl_this_data->current_view) {
                       VDATA(phdl_this_data->current_view)->flags &= ~VF_DISPLAY;      /* mark as no longer */
                       /* displayed. */
               }
               phdl_this_data->current_view = v;

               cp = phdl_this_data->frames[F_LACE_STORE_LONG];
#if defined (GRF_ECS) || defined (GRF_AGA)
#if defined (GRF_AGA)
               tmp = find_copper_inst(cp, CI_MOVE(R_FMODE));
               tmp->cp.inst.operand = 0;
#endif
               tmp = find_copper_inst(cp, CI_MOVE(R_BEAMCON0));
               tmp->cp.inst.operand = phdl_this_data->beamcon0;
               tmp = find_copper_inst(cp, CI_MOVE(R_DIWHIGH));
               tmp->cp.inst.operand = CALC_DIWHIGH(hstart, vstart, hstop, vstop);
#endif /* ECS */
               tmp = find_copper_inst(cp, CI_MOVE(R_BPLCON0));
               tmp->cp.inst.operand = phdl_this_data->bplcon0 | ((depth & 0x7) << 13); /* times two. */
               tmp = find_copper_inst(cp, CI_MOVE(R_BPLCON1));
               tmp->cp.inst.operand = con1;
               tmp = find_copper_inst(cp, CI_MOVE(R_DIWSTART));
               tmp->cp.inst.operand = ((vstart & 0xff) << 8) | (hstart & 0xff);
               tmp = find_copper_inst(cp, CI_MOVE(R_DIWSTOP));
               tmp->cp.inst.operand = ((vstop & 0xff) << 8) | (hstop & 0xff);
               tmp = find_copper_inst(cp, CI_MOVE(R_DDFSTART));
               tmp->cp.inst.operand = ddfstart;
               tmp = find_copper_inst(cp, CI_MOVE(R_DDFSTOP));
               tmp->cp.inst.operand = ddfstart + ddfwidth;

               mod1l = v->bitmap->bytes_per_row + v->bitmap->row_mod;
               mod2l = mod1l << 1;

               tmp = find_copper_inst(cp, CI_MOVE(R_BPL0PTH));
               tmp[0].cp.inst.operand = HIADDR(PREP_DMA_MEM(&v->bitmap->plane[0][0])); /* update plane
                                                                                        * pointers. */
               tmp[1].cp.inst.operand = LOADDR(PREP_DMA_MEM(&v->bitmap->plane[0][0])); /* high and low. */
               tmp[2].cp.inst.operand = HIADDR(PREP_DMA_MEM(&v->bitmap->plane[0][mod1l]));     /* update plane
                                                                                                * pointers. */
               tmp[3].cp.inst.operand = LOADDR(PREP_DMA_MEM(&v->bitmap->plane[0][mod1l]));     /* high and low. */
               if (depth == 2) {
                       tmp[4].cp.inst.operand = HIADDR(PREP_DMA_MEM(&v->bitmap->plane[1][0])); /* update plane
                                                                                                * pointers. */
                       tmp[5].cp.inst.operand = LOADDR(PREP_DMA_MEM(&v->bitmap->plane[1][0])); /* high and low. */
                       tmp[6].cp.inst.operand = HIADDR(PREP_DMA_MEM(&v->bitmap->plane[1][mod1l]));     /* update plane
                                                                                                        * pointers. */
                       tmp[7].cp.inst.operand = LOADDR(PREP_DMA_MEM(&v->bitmap->plane[1][mod1l]));     /* high and low. */
               }
               /* set mods correctly. */
               tmp = find_copper_inst(cp, CI_MOVE(R_BPL1MOD));
               tmp[0].cp.inst.operand = mod2l + mod1l;
               tmp[1].cp.inst.operand = mod2l + mod1l;

               /* set next pointers correctly */
               tmp = find_copper_inst(cp, CI_MOVE(R_COP1LCH));
               tmp[0].cp.inst.operand = HIADDR(PREP_DMA_MEM(phdl_this_data->frames[F_LACE_STORE_SHORT]));
               tmp[1].cp.inst.operand = LOADDR(PREP_DMA_MEM(phdl_this_data->frames[F_LACE_STORE_SHORT]));

               memcpy(phdl_this_data->frames[F_LACE_STORE_SHORT], phdl_this_data->frames[F_LACE_STORE_LONG], std_dlace_copper_list_size);

               /* these are the only ones that are different from long frame. */
               cp = phdl_this_data->frames[F_LACE_STORE_SHORT];
               tmp = find_copper_inst(cp, CI_MOVE(R_BPL0PTH));
               tmp[0].cp.inst.operand = HIADDR(PREP_DMA_MEM(&v->bitmap->plane[0][mod2l]));     /* update plane
                                                                                                * pointers. */
               tmp[1].cp.inst.operand = LOADDR(PREP_DMA_MEM(&v->bitmap->plane[0][mod2l]));     /* high and low. */
               tmp[2].cp.inst.operand = HIADDR(PREP_DMA_MEM(&v->bitmap->plane[0][mod2l + mod1l]));     /* update plane
                                                                                                        * pointers. */
               tmp[3].cp.inst.operand = LOADDR(PREP_DMA_MEM(&v->bitmap->plane[0][mod2l + mod1l]));     /* high and low. */
               if (depth == 2) {
                       tmp[4].cp.inst.operand = HIADDR(PREP_DMA_MEM(&v->bitmap->plane[1][mod2l]));     /* update plane
                                                                                                        * pointers. */
                       tmp[5].cp.inst.operand = LOADDR(PREP_DMA_MEM(&v->bitmap->plane[1][mod2l]));     /* high and low. */
                       tmp[6].cp.inst.operand = HIADDR(PREP_DMA_MEM(&v->bitmap->plane[1][mod2l + mod1l]));     /* update plane
                                                                                                                * pointers. */
                       tmp[7].cp.inst.operand = LOADDR(PREP_DMA_MEM(&v->bitmap->plane[1][mod2l + mod1l]));     /* high and low. */
               }
               /* set next pointers correctly */
               tmp = find_copper_inst(cp, CI_MOVE(R_COP1LCH));
               tmp[0].cp.inst.operand = HIADDR(PREP_DMA_MEM(phdl_this_data->frames[F_LACE_STORE_LONG]));
               tmp[1].cp.inst.operand = LOADDR(PREP_DMA_MEM(phdl_this_data->frames[F_LACE_STORE_LONG]));

               cp = phdl_this_data->frames[F_LACE_LONG];
               phdl_this_data->frames[F_LACE_LONG] = phdl_this_data->frames[F_LACE_STORE_LONG];
               phdl_this_data->frames[F_LACE_STORE_LONG] = cp;

               cp = phdl_this_data->frames[F_LACE_SHORT];
               phdl_this_data->frames[F_LACE_SHORT] = phdl_this_data->frames[F_LACE_STORE_SHORT];
               phdl_this_data->frames[F_LACE_STORE_SHORT] = cp;

               vd->flags |= VF_DISPLAY;

               cc_a2024_use_colormap(v, vd->colormap);
       }
       cc_load_mode(phdl_this);
}

dmode_t *
cc_init_pal_a2024(void)
{
       /* this function should only be called once. */
       if (!p24_this) {
               int     i;
               u_short len = std_pal_a2024_copper_list_len;
               cop_t  *cp;

               p24_this = &pal_a2024_mode;
               p24_this_data = &pal_a2024_mode_data;
               memset(p24_this, 0, sizeof(dmode_t));
               memset(p24_this_data, 0, sizeof(dmdata_t));

               p24_this->name = "pal: A2024 15 kHz";
               p24_this->nominal_size.width = 1024;
               p24_this->nominal_size.height = 1024;
               p24_this_data->max_size.width = 1024;
               p24_this_data->max_size.height = 1024;
               p24_this_data->min_size.width = 1024;
               p24_this_data->min_size.height = 1024;
               p24_this_data->min_depth = 1;
               p24_this_data->max_depth = 2;
               p24_this->data = p24_this_data;

               p24_this->get_monitor = cc_get_monitor;
               p24_this->alloc_view = cc_alloc_view;
               p24_this->get_current_view = cc_get_current_view;

               p24_this_data->use_colormap = cc_a2024_use_colormap;
               p24_this_data->get_colormap = cc_a2024_get_colormap;
               p24_this_data->display_view = display_pal_a2024_view;
               p24_this_data->alloc_colormap = cc_a2024_alloc_colormap;
               p24_this_data->monitor = cc_monitor;

               p24_this_data->flags |= DMF_HEDLEY_EXP;

               p24_this_data->frames = pal_a2024_frames;
               p24_this_data->frames[F_QD_QUAD0] = alloc_chipmem(std_pal_a2024_copper_list_size * F_QD_TOTAL);
               if (!p24_this_data->frames[F_QD_QUAD0]) {
                       panic("couldn't get chipmem for copper list");
               }
               /* setup the hedley init bitplane. */
               hedley_init = alloc_chipmem(128);
               if (!hedley_init) {
                       panic("couldn't get chipmem for hedley init bitplane");
               }
               for (i = 1; i < 128; i++)
                       hedley_init[i] = 0xff;
               hedley_init[0] = 0x03;

               /* copy image of standard copper list. */
               memcpy(p24_this_data->frames[0], std_pal_a2024_copper_list, std_pal_a2024_copper_list_size);

               /* set the init plane pointer. */
               cp = find_copper_inst(p24_this_data->frames[F_QD_QUAD0], CI_MOVE(R_BPL0PTH));
               cp[0].cp.inst.operand = HIADDR(PREP_DMA_MEM(hedley_init));
               cp[1].cp.inst.operand = LOADDR(PREP_DMA_MEM(hedley_init));

               for (i = 1; i < F_QD_TOTAL; i++) {
                       p24_this_data->frames[i] = &p24_this_data->frames[i - 1][len];
                       memcpy(p24_this_data->frames[i], p24_this_data->frames[0], std_pal_a2024_copper_list_size);
               }

               p24_this_data->bplcon0 = 0x8200;        /* hires */
               p24_this_data->vbl_handler = (vbl_handler_func *) pal_a2024_mode_vbl_handler;


               LIST_INSERT_HEAD(&MDATA(cc_monitor)->modes, p24_this, link);
       }
       return (p24_this);
}

void
display_pal_a2024_view(view_t *v)
{
       if (p24_this_data->current_view != v) {
               vdata_t *vd = VDATA(v);
               cop_t  *cp, *tmp;
               u_char *inst_plane[2] = { NULL, NULL };
               u_char **plane = inst_plane;
               u_long  full_line = v->bitmap->bytes_per_row + v->bitmap->row_mod;
               u_long  half_plane = full_line * v->bitmap->rows / 2;

               int     depth = v->bitmap->depth, i, j;

               plane[0] = v->bitmap->plane[0];
               if (depth == 2) {
                       plane[1] = v->bitmap->plane[1];
               }
               if (p24_this_data->current_view) {
                       VDATA(p24_this_data->current_view)->flags &= ~VF_DISPLAY;       /* mark as no longer
                                                                                        * displayed. */
               }
               cp = p24_this_data->frames[F_QD_STORE_QUAD0];
               tmp = find_copper_inst(cp, CI_MOVE(R_COLOR1F));
               tmp = find_copper_inst(tmp, CI_MOVE(R_BPLCON0));        /* grab third one. */
               tmp->cp.inst.operand = p24_this_data->bplcon0 | ((depth & 0x7) << 13);  /* times 2 */

               memcpy(p24_this_data->frames[F_QD_STORE_QUAD1], p24_this_data->frames[F_QD_STORE_QUAD0], std_pal_a2024_copper_list_size);
               memcpy(p24_this_data->frames[F_QD_STORE_QUAD2], p24_this_data->frames[F_QD_STORE_QUAD0], std_pal_a2024_copper_list_size);
               memcpy(p24_this_data->frames[F_QD_STORE_QUAD3], p24_this_data->frames[F_QD_STORE_QUAD0], std_pal_a2024_copper_list_size);

               /*
                * Mark Id's
                */
               tmp = find_copper_inst(p24_this_data->frames[F_QD_STORE_QUAD1], CI_WAIT(126, 29));
               CBUMP(tmp);
               CMOVE(tmp, R_COLOR01, QUAD1_ID);
               tmp = find_copper_inst(p24_this_data->frames[F_QD_STORE_QUAD2], CI_WAIT(126, 29));
               CBUMP(tmp);
               CMOVE(tmp, R_COLOR01, QUAD2_ID);
               tmp = find_copper_inst(p24_this_data->frames[F_QD_STORE_QUAD3], CI_WAIT(126, 29));
               CBUMP(tmp);
               CMOVE(tmp, R_COLOR01, QUAD3_ID);

               plane[0]--;
               plane[0]--;
               if (depth == 2) {
                       plane[1]--;
                       plane[1]--;
               }
               /*
                * Set bitplane pointers.
                */
               tmp = find_copper_inst(p24_this_data->frames[F_QD_STORE_QUAD0], CI_MOVE(R_BPLMOD2));
               CBUMP(tmp);
               CMOVE(tmp, R_BPL0PTH, HIADDR(PREP_DMA_MEM(&plane[0][0])));
               CMOVE(tmp, R_BPL0PTL, LOADDR(PREP_DMA_MEM(&plane[0][0])));
               CMOVE(tmp, R_BPL1PTH, HIADDR(PREP_DMA_MEM(&plane[0][full_line])));
               CMOVE(tmp, R_BPL1PTL, LOADDR(PREP_DMA_MEM(&plane[0][full_line])));
               if (depth == 2) {
                       CMOVE(tmp, R_BPL2PTH, HIADDR(PREP_DMA_MEM(&plane[1][0])));
                       CMOVE(tmp, R_BPL2PTL, LOADDR(PREP_DMA_MEM(&plane[1][0])));
                       CMOVE(tmp, R_BPL3PTH, HIADDR(PREP_DMA_MEM(&plane[1][full_line])));
                       CMOVE(tmp, R_BPL3PTL, LOADDR(PREP_DMA_MEM(&plane[1][full_line])));
               }
#if defined (GRF_ECS) || defined (GRF_AGA)
               CMOVE(tmp, R_DIWHIGH, 0x2100);
#endif
               CMOVE(tmp, R_COP1LCH, HIADDR(PREP_DMA_MEM(p24_this_data->frames[F_QD_STORE_QUAD1])));
               CMOVE(tmp, R_COP1LCL, LOADDR(PREP_DMA_MEM(p24_this_data->frames[F_QD_STORE_QUAD1])));
               CEND(tmp);
               CEND(tmp);

               tmp = find_copper_inst(p24_this_data->frames[F_QD_STORE_QUAD1], CI_MOVE(R_BPLMOD2));
               CBUMP(tmp);
               CMOVE(tmp, R_BPL0PTH, HIADDR(PREP_DMA_MEM(&plane[0][HALF_2024_LINE])));
               CMOVE(tmp, R_BPL0PTL, LOADDR(PREP_DMA_MEM(&plane[0][HALF_2024_LINE])));
               CMOVE(tmp, R_BPL1PTH, HIADDR(PREP_DMA_MEM(&plane[0][full_line + HALF_2024_LINE])));
               CMOVE(tmp, R_BPL1PTL, LOADDR(PREP_DMA_MEM(&plane[0][full_line + HALF_2024_LINE])));
               if (depth == 2) {
                       CMOVE(tmp, R_BPL2PTH, HIADDR(PREP_DMA_MEM(&plane[1][HALF_2024_LINE])));
                       CMOVE(tmp, R_BPL2PTL, LOADDR(PREP_DMA_MEM(&plane[1][HALF_2024_LINE])));
                       CMOVE(tmp, R_BPL3PTH, HIADDR(PREP_DMA_MEM(&plane[1][full_line + HALF_2024_LINE])));
                       CMOVE(tmp, R_BPL3PTL, LOADDR(PREP_DMA_MEM(&plane[1][full_line + HALF_2024_LINE])));
               }
#if defined (GRF_ECS) || defined (GRF_AGA)
               CMOVE(tmp, R_DIWHIGH, 0x2100);
#endif
               CMOVE(tmp, R_COP1LCH, HIADDR(PREP_DMA_MEM(p24_this_data->frames[F_QD_STORE_QUAD2])));
               CMOVE(tmp, R_COP1LCL, LOADDR(PREP_DMA_MEM(p24_this_data->frames[F_QD_STORE_QUAD2])));
               CEND(tmp);
               CEND(tmp);

               tmp = find_copper_inst(p24_this_data->frames[F_QD_STORE_QUAD2], CI_MOVE(R_BPLMOD2));
               CBUMP(tmp);
               CMOVE(tmp, R_BPL0PTH, HIADDR(PREP_DMA_MEM(&plane[0][half_plane])));
               CMOVE(tmp, R_BPL0PTL, LOADDR(PREP_DMA_MEM(&plane[0][half_plane])));
               CMOVE(tmp, R_BPL1PTH, HIADDR(PREP_DMA_MEM(&plane[0][half_plane + full_line])));
               CMOVE(tmp, R_BPL1PTL, LOADDR(PREP_DMA_MEM(&plane[0][half_plane + full_line])));
               if (depth == 2) {
                       CMOVE(tmp, R_BPL2PTH, HIADDR(PREP_DMA_MEM(&plane[1][half_plane])));
                       CMOVE(tmp, R_BPL2PTL, LOADDR(PREP_DMA_MEM(&plane[1][half_plane])));
                       CMOVE(tmp, R_BPL3PTH, HIADDR(PREP_DMA_MEM(&plane[1][half_plane + full_line])));
                       CMOVE(tmp, R_BPL3PTL, LOADDR(PREP_DMA_MEM(&plane[1][half_plane + full_line])));
               }
#if defined (GRF_ECS) || defined (GRF_AGA)
               CMOVE(tmp, R_DIWHIGH, 0x2100);
#endif
               CMOVE(tmp, R_COP1LCH, HIADDR(PREP_DMA_MEM(p24_this_data->frames[F_QD_STORE_QUAD3])));
               CMOVE(tmp, R_COP1LCL, LOADDR(PREP_DMA_MEM(p24_this_data->frames[F_QD_STORE_QUAD3])));
               CEND(tmp);
               CEND(tmp);

               tmp = find_copper_inst(p24_this_data->frames[F_QD_STORE_QUAD3], CI_MOVE(R_BPLMOD2));
               CBUMP(tmp);
               CMOVE(tmp, R_BPL0PTH, HIADDR(PREP_DMA_MEM(&plane[0][half_plane + HALF_2024_LINE])));
               CMOVE(tmp, R_BPL0PTL, LOADDR(PREP_DMA_MEM(&plane[0][half_plane + HALF_2024_LINE])));
               CMOVE(tmp, R_BPL1PTH, HIADDR(PREP_DMA_MEM(&plane[0][half_plane + full_line + HALF_2024_LINE])));
               CMOVE(tmp, R_BPL1PTL, LOADDR(PREP_DMA_MEM(&plane[0][half_plane + full_line + HALF_2024_LINE])));
               if (depth == 2) {
                       CMOVE(tmp, R_BPL2PTH, HIADDR(PREP_DMA_MEM(&plane[1][half_plane + HALF_2024_LINE])));
                       CMOVE(tmp, R_BPL2PTL, LOADDR(PREP_DMA_MEM(&plane[1][half_plane + HALF_2024_LINE])));
                       CMOVE(tmp, R_BPL3PTH, HIADDR(PREP_DMA_MEM(&plane[1][half_plane + full_line + HALF_2024_LINE])));
                       CMOVE(tmp, R_BPL3PTL, LOADDR(PREP_DMA_MEM(&plane[1][half_plane + full_line + HALF_2024_LINE])));
               }
#if defined (GRF_ECS) || defined (GRF_AGA)
               CMOVE(tmp, R_DIWHIGH, 0x2100);
#endif
               CMOVE(tmp, R_COP1LCH, HIADDR(PREP_DMA_MEM(p24_this_data->frames[F_QD_STORE_QUAD0])));
               CMOVE(tmp, R_COP1LCL, LOADDR(PREP_DMA_MEM(p24_this_data->frames[F_QD_STORE_QUAD0])));
               CEND(tmp);
               CEND(tmp);

               /* swap new pointers in. */
               for (i = F_QD_STORE_QUAD0, j = F_QD_QUAD0;
                   i <= F_QD_STORE_QUAD3; i++, j++) {
                       cp = p24_this_data->frames[j];
                       p24_this_data->frames[j] = p24_this_data->frames[i];
                       p24_this_data->frames[i] = cp;
               }

               p24_this_data->current_view = v;
               vd->flags |= VF_DISPLAY;

               cc_a2024_use_colormap(v, vd->colormap);
       }
       cc_load_mode(p24_this);
}

void
pal_a2024_mode_vbl_handler(dmode_t *d)
{
       u_short vp = ((custom.vposr & 0x0007) << 8) | ((custom.vhposr) >> 8);

       if (vp < 20) {
               custom.cop1lc = PREP_DMA_MEM(p24_this_data->frames[p24_this_data->hedley_current]);
               custom.copjmp1 = 0;
       }
       p24_this_data->hedley_current++;
       p24_this_data->hedley_current &= 0x3;   /* if 4 then 0. */
}
#endif /* GRF_A2024 */

#if defined (GRF_AGA)

dmode_t *
cc_init_pal_aga(void)
{
       /* this function should only be called once. */
       if (!paga_this && (custom.deniseid & 0xff) == 0xf8 &&
           aga_enable & AGA_ENABLE) {
               u_short len = aga_copper_list_len;

               paga_this = &paga_mode;
               paga_this_data = &paga_mode_data;
               memset(paga_this, 0, sizeof(dmode_t));
               memset(paga_this_data, 0, sizeof(dmdata_t));

               paga_this->name = "pal: AGA dbl";
               paga_this->nominal_size.width = 640;
               paga_this->nominal_size.height = 512;
               paga_this_data->max_size.width = 720;
               paga_this_data->max_size.height = 564;
               paga_this_data->min_size.width = 320;
               paga_this_data->min_size.height = 200;
               paga_this_data->min_depth = 1;
               paga_this_data->max_depth = 8;
               paga_this->data = paga_this_data;

               paga_this->get_monitor = cc_get_monitor;
               paga_this->alloc_view = cc_alloc_view;
               paga_this->get_current_view = cc_get_current_view;

               paga_this_data->use_colormap = cc_use_aga_colormap;
               paga_this_data->get_colormap = cc_get_colormap;
               paga_this_data->alloc_colormap = cc_alloc_aga_colormap;
               paga_this_data->display_view = display_pal_aga_view;
               paga_this_data->monitor = cc_monitor;

               paga_this_data->frames = paga_frames;
               paga_this_data->frames[F_LONG] = alloc_chipmem(aga_copper_list_size * F_TOTAL);
               if (!paga_this_data->frames[F_LONG]) {
                       panic("couldn't get chipmem for copper list");
               }
               paga_this_data->frames[F_STORE_LONG] = &paga_this_data->frames[F_LONG][len];

               memcpy(paga_this_data->frames[F_STORE_LONG], aga_copper_list, aga_copper_list_size);
               memcpy(paga_this_data->frames[F_LONG], aga_copper_list, aga_copper_list_size);

               paga_this_data->bplcon0 = 0x0240 | USE_CON3;    /* color composite
                                                                * enable,
                                                                * shres. */
               paga_this_data->std_start_x = 0x4f /*STANDARD_VIEW_X*/;
               paga_this_data->std_start_y = 0x2b /*STANDARD_VIEW_Y*/;
               paga_this_data->vbl_handler = (vbl_handler_func *) cc_mode_vbl_handler;
               paga_this_data->beamcon0 = STANDARD_PAL_BEAMCON | (SPECIAL_BEAMCON ^ VSYNCTRUE);

               LIST_INSERT_HEAD(&MDATA(cc_monitor)->modes,
                   paga_this, link);
       }
       return (paga_this);
}

/* static, so I can patch and play */

#ifdef GRF_AGA_VGA
int     pAGA_htotal  = 0x079;
int     pAGA_vtotal  = 0x24d;
int     pAGA_vbstop  = 0x019;
int     pAGA_hcenter = 0x04b;
#else
int     pAGA_htotal  = 0x081;
int     pAGA_vtotal  = 0x23d;
int     pAGA_vbstop  = 0x017;
int     pAGA_hcenter = 0x04f;
#endif
int     pAGA_hsstrt  = 0x00f;
int     pAGA_hsstop  = 0x019;
int     pAGA_hbstrt  = 0x001;
int     pAGA_hbstop  = 0x021;
int     pAGA_vsstrt  = 0x001;
int     pAGA_vsstop  = 0x008;
int     pAGA_vbstrt  = 0x000;

void
display_pal_aga_view(view_t *v)
{
       if (paga_this_data->current_view != v) {
               vdata_t *vd = VDATA(v);
               cop_t  *cp = paga_this_data->frames[F_STORE_LONG], *tmp;
               int     depth = v->bitmap->depth, i;
               int     hstart, hstop, vstart, vstop, j;
               int     x, y, w = v->display.width, h = v->display.height;
               u_short ddfstart, ddfwidth, con1;

#ifdef DEBUG
               if (aga_enable & AGA_TRACE)
                       printf("display_aga_view(%dx%dx%d) %p\n", w, h,
                           depth, v);
#endif
               /* round down to nearest even width */
               /* w &= 0xfffe; */
               /* calculate datafetch width. */

               ddfwidth = ((v->bitmap->bytes_per_row >> 1) - 4) << 1;

               /* this will center the any overscanned display */
               /* and allow user to modify. */
               x = v->display.x + paga_this_data->std_start_x - ((w - 640) >> 3);
               y = v->display.y + paga_this_data->std_start_y - ((h - 512) >> 1);

               if (y & 1)
                       y--;

               if (!(x & 1))
                       x--;

               hstart = x;
               hstop = x + (w >> 2);
               vstart = y;
               vstop = y + (h >> 0);
               ddfstart = (hstart >> 1) - 8;

#ifdef DEBUG
               if (aga_enable & AGA_TRACE2) {
                       printf ("  ddfwidth %04x x %04x y %04x", ddfwidth,
                           x, y);
                       printf (" hstart %04x hstop %04x vstart %04x vstop %04x ddfstart %04x\n",
                           hstart, hstop, vstart, vstop, ddfstart);
               }
#endif
               /* check for hardware limits, AGA may allow more..? */
               /* anyone got a 4000 I can borrow :^) -ch */
               if ((ddfstart & 0xfffc) + ddfwidth > 0xd8) {
                       int     d = 0;

                       /* XXX anyone know the equality properties of
                        * intermixed logial AND's */
                       /* XXX and arithmetic operators? */
                       while (((ddfstart & 0xfffc) + ddfwidth - d) > 0xd8) {
                               d++;
                       }

                       ddfstart -= d;
                       hstart -= d << 1;
                       hstop -= d << 1;
               }
               /* correct the datafetch to proper limits. */
               /* delay the actual display of the data until we need it. */
               ddfstart &= 0xfffc;
#ifdef DEBUG
               if (aga_enable & AGA_TRACE2) {
                       printf ("  ddfwidth %04x x %04x y %04x", ddfwidth,
                           x, y);
                       printf (" hstart %04x hstop %04x vstart %04x vstop %04x ddfstart %04x\n",
                           hstart, hstop, vstart, vstop, ddfstart);
               }
#endif
               con1 = ((hstart - 9) - (ddfstart << 1)) | (((hstart - 9) - (ddfstart << 1)) << 4);

               if (paga_this_data->current_view) {
                       VDATA(paga_this_data->current_view)->flags &= ~VF_DISPLAY;      /* mark as no longer */
                       /* displayed. */
               }
               paga_this_data->current_view = v;

               cp = paga_this_data->frames[F_STORE_LONG];
               tmp = cp;
               for (i = 0; i < 8; ++i) {
                       if (tmp == NULL)
                               break;
                       tmp = find_copper_inst(tmp + 1, CI_MOVE(R_BPLCON3));
                       if (tmp == NULL)
                               break;
                       tmp->cp.inst.operand = 0x0ca1 | (i << 13);
                       tmp = find_copper_inst(tmp + 1, CI_MOVE(R_BPLCON3));
                       if (tmp == NULL)
                               break;
                       tmp->cp.inst.operand = 0x0ea1 | (i << 13);
               }
               if (tmp)
                       tmp = find_copper_inst(tmp + 1, CI_MOVE(R_BPLCON3));
               if (tmp)
                       tmp->cp.inst.operand = 0x0ca1;
               tmp = find_copper_inst(cp, CI_MOVE(R_FMODE));
               tmp->cp.inst.operand = 0x8003;
               tmp = find_copper_inst(cp, CI_MOVE(R_HTOTAL));
               tmp->cp.inst.operand = pAGA_htotal; /* 81/71/73/79? */
               tmp = find_copper_inst(cp, CI_MOVE(R_HBSTRT));
               tmp->cp.inst.operand = pAGA_hbstrt; /* 0x0008 */
               tmp = find_copper_inst(cp, CI_MOVE(R_HSSTRT));
               tmp->cp.inst.operand = pAGA_hsstrt; /* 0x000e */
               tmp = find_copper_inst(cp, CI_MOVE(R_HSSTOP));
               tmp->cp.inst.operand = pAGA_hsstop; /* 0x001c */
               tmp = find_copper_inst(cp, CI_MOVE(R_HBSTOP));
               tmp->cp.inst.operand = pAGA_hsstop; /* 0x001e */
               tmp = find_copper_inst(cp, CI_MOVE(R_HCENTER));
               tmp->cp.inst.operand = pAGA_hcenter; /*AGA_htotal / 2 + AGA_hsstrt */
               tmp = find_copper_inst(cp, CI_MOVE(R_VBSTRT));
               tmp->cp.inst.operand = pAGA_vbstrt; /* 0x0000 */
               tmp = find_copper_inst(cp, CI_MOVE(R_VSSTRT));
               tmp->cp.inst.operand = pAGA_vsstrt; /* 0x016b / AGA_htotal */
               tmp = find_copper_inst(cp, CI_MOVE(R_VSSTOP));
               tmp->cp.inst.operand = pAGA_vsstop; /* 0x02d6 / AGA_htotal */
               tmp = find_copper_inst(cp, CI_MOVE(R_VBSTOP));
               tmp->cp.inst.operand = pAGA_vbstop; /* 0x0bd1 / AGA_htotal */
               tmp = find_copper_inst(cp, CI_MOVE(R_VTOTAL));
               tmp->cp.inst.operand = pAGA_vtotal;
               tmp = find_copper_inst(cp, CI_MOVE(R_BEAMCON0));
               tmp->cp.inst.operand = paga_this_data->beamcon0;
#ifdef DEBUG
               if (aga_enable & AGA_TRACE2)
                       printf("  beamcon0 %04x", tmp->cp.inst.operand);
#endif
               tmp = find_copper_inst(cp, CI_MOVE(R_DIWHIGH));
               tmp->cp.inst.operand = CALC_DIWHIGH(hstart, vstart, hstop, vstop);
#ifdef DEBUG
               if (aga_enable & AGA_TRACE2)
                       printf(" diwhigh %04x>", tmp->cp.inst.operand);
#endif
#if 0
               tmp->cp.inst.operand = (vstop & 0x0700) | ((hstop & 0x0100) << 5);
#endif
#ifdef DEBUG
               if (aga_enable & AGA_TRACE2)
                       printf("%04x", tmp->cp.inst.operand);
#endif
               tmp = find_copper_inst(cp, CI_MOVE(R_BPLCON0));
               tmp->cp.inst.operand = paga_this_data->bplcon0 |
                   ((depth & 0x7) << 12) | ((depth & 0x8) << 1);
#ifdef DEBUG
               if (aga_enable & AGA_TRACE2)
                       printf(" bplcon0 %04x", tmp->cp.inst.operand);
#endif
               tmp = find_copper_inst(cp, CI_MOVE(R_BPLCON1));
               tmp->cp.inst.operand = con1;
#ifdef DEBUG
               if (aga_enable & AGA_TRACE2)
                       printf(" bplcon1 %04x>0000\n", con1);
#endif
               tmp = find_copper_inst(cp, CI_MOVE(R_DIWSTART));
               tmp->cp.inst.operand = ((vstart & 0xff) << 8) | (hstart & 0xff);
#ifdef DEBUG
               if (aga_enable & AGA_TRACE2)
                       printf("  diwstart %04x", tmp->cp.inst.operand);
#endif
               tmp = find_copper_inst(cp, CI_MOVE(R_DIWSTOP));
               tmp->cp.inst.operand = ((vstop & 0xff) << 8) | (hstop & 0xff);
#ifdef DEBUG
               if (aga_enable & AGA_TRACE2)
                       printf(" diwstop %04x", tmp->cp.inst.operand);
#endif
               tmp = find_copper_inst(cp, CI_MOVE(R_DDFSTART));
               tmp->cp.inst.operand = ddfstart;
#ifdef DEBUG
               if (aga_enable & AGA_TRACE2)
                       printf(" ddfstart %04x", tmp->cp.inst.operand);
#endif
               tmp = find_copper_inst(cp, CI_MOVE(R_DDFSTOP));
               tmp->cp.inst.operand = ddfstart + ddfwidth;
#ifdef DEBUG
               if (aga_enable & AGA_TRACE2)
                       printf(" ddfstop %04x", tmp->cp.inst.operand);
#endif

               tmp = find_copper_inst(cp, CI_MOVE(R_BPL0PTH));
               for (i = 0, j = 0; i < depth; j += 2, i++) {
                       /* update the plane pointers */
                       tmp[j].cp.inst.operand = HIADDR(PREP_DMA_MEM(v->bitmap->plane[i]));
                       tmp[j + 1].cp.inst.operand = LOADDR(PREP_DMA_MEM(v->bitmap->plane[i]));
#ifdef DEBUG
               if (aga_enable & AGA_TRACE2)
                       printf (" bpl%dpth %p", i, v->bitmap->plane[i]);
#endif
               }

               /* set mods correctly. */
               tmp = find_copper_inst(cp, CI_MOVE(R_BPL1MOD));
               tmp[0].cp.inst.operand = v->bitmap->row_mod;
               tmp[1].cp.inst.operand = v->bitmap->row_mod;
#ifdef DEBUG
               if (aga_enable & AGA_TRACE2)
                       printf(" bplxmod %04x\n", v->bitmap->row_mod);
#endif

               /* set next pointers correctly */
               tmp = find_copper_inst(cp, CI_MOVE(R_COP1LCH));
               tmp[0].cp.inst.operand = HIADDR(PREP_DMA_MEM(paga_this_data->frames[F_STORE_LONG]));
               tmp[1].cp.inst.operand = LOADDR(PREP_DMA_MEM(paga_this_data->frames[F_STORE_LONG]));

               cp = paga_this_data->frames[F_LONG];
               paga_this_data->frames[F_LONG] = paga_this_data->frames[F_STORE_LONG];
               paga_this_data->frames[F_STORE_LONG] = cp;

               vd->flags |= VF_DISPLAY;

               cc_use_aga_colormap(v, vd->colormap);
       }
       cc_load_mode(paga_this);
#ifdef DEBUG
       if (aga_enable & AGA_TRACE)
               aga_enable |= AGA_TRACE2;       /* XXXX */
#endif
}

#endif /* GRF_AGA */
#endif /* GRF_PAL */

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.