initial import of NetBSD tree

1 files changed, 303 insertions, 0 deletions

diff --git a/sys/arch/amiga/dev/grfabs_reg.h b/sys/arch/amiga/dev/grfabs_reg.h
new file mode 100644
index 00000000000..d1677c94724
--- /dev/null
+++ b/sys/arch/amiga/dev/grfabs_reg.h
@@ -0,0 +1,303 @@
+/*	$NetBSD: grfabs_reg.h,v 1.4 1994/10/26 02:03:29 cgd 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.
+ */
+
+#if ! defined (_GRFABS_REG_H)
+#define _GRFABS_REG_H
+
+struct point {
+    long x;
+    long y;
+};
+typedef struct point point_t;
+
+struct dimension {
+    u_long width;
+    u_long height;
+};
+typedef struct dimension dimen_t;
+
+struct box {
+    long x;
+    long y;
+    u_long width;
+    u_long height;
+};
+typedef struct box box_t;
+
+struct rectangle {
+    long left;
+    long top;
+    long right;
+    long bottom;
+};
+
+typedef struct rectangle rect_t;
+
+typedef struct bitmap bmap_t;
+typedef struct colormap colormap_t;
+typedef struct view view_t;
+typedef struct display_mode dmode_t;
+typedef struct monitor monitor_t;
+
+LIST_HEAD(monitor_list, monitor);
+extern struct monitor_list *monitors;
+
+/*
+ * Bitmap stuff.
+ */
+
+/*
+ * Note structure is 5 long words big.  This may come in handy for
+ * contiguous allocations 
+ * 
+ * Please do fill in everything correctly this is the main input for
+ * all other programs.  In other words all problems with RTG start here.
+ * If you do not mimic everyone else exactly problems will appear.
+ * If you need a template look at alloc_bitmap() in grf_cc.c.
+ *
+ * WARNING: the plane array is only for convience, all data for bitplanes 
+ *	MUST be contiguous.  This is for mapping purposes.  The reason
+ *	for the plane pointers and row_mod is to support interleaving
+ *	on monitors that wish to support this. 
+ *	
+ * 2nd Warning: Also don't get funky with these pointers you are expected
+ *	to place the start of mappable plane data in ``hardware_address'',
+ *	``hardware_address'' is the only thing that /dev/view checks and it
+ *	expects the planes to follow with no padding in between.  If you have
+ *	special alignment requirements make use of the given fields
+ *	so that the entire contiguous plane data is exactly:
+ *	bytes_per_row*height*depth long starting at the physical address
+ *	contained within hardware_address.
+ *	
+ * Final Warning: Plane data must begin on a PAGE address and the allocation
+ *	must be ``n'' PAGES big do to mapping requirements (otherwise the
+ *	user could write over non-allocated memory.
+ *	
+ */
+struct bitmap {
+    u_short   bytes_per_row;	  /* number of bytes per display row. */
+    u_short   row_mod;		  /* number of bytes to reach next row. */
+    u_short   rows;		  /* number of display rows. */
+    u_short   depth;		  /* depth of bitmap. */
+    u_short   flags;		  /* flags. */
+    u_short   pad;
+    u_char  *blit_temp;		  /* private monitor buffer. */
+    u_char **plane;		  /* plane data for bitmap. */
+    u_char  *hardware_address;	  /* mappable bitplane pointer. */
+};
+
+enum bitmap_flag_bits {
+    BMB_CLEAR,			  /* init only. */
+    BMB_INTERLEAVED,		  /* init/read. */
+    BMB_ALIGN64,		  /* init/read. */
+};
+
+enum bitmap_flags {
+    BMF_CLEAR = 1 << BMB_CLEAR,			  /* init only. */
+    BMF_INTERLEAVED = 1 << BMB_INTERLEAVED,	  /* init/read. */
+    BMF_ALIGN64 = 1 << BMB_ALIGN64		  /* init/read. */
+};
+
+/* Use these macros to find misc. sizes of actual bitmap */
+#define BM_WIDTH(b)	((b)->bytes_per_row << 3)
+#define BM_HEIGHT(b)	((b)->rows)
+#define BM_ROW(b,p,l) \
+    ((b)->plane[p] + (((b)->bytes_per_row + (b)->row_mod) * l))
+
+/*
+ * Colormap stuff.
+ */
+
+/*
+ * valid masks are a bitfield of zeros followed by ones that indicate 
+ * which mask are valid for each component.  The ones and zeros will 
+ * be contiguous so adding one to this value yields the number of
+ * levels for that component. 
+ * -ch 
+ */
+
+struct colormap {
+    u_char type;	/* what type of entries these are. */
+    union {
+        /* CM_GREYSCALE */
+        u_char grey;
+#define grey_mask  valid_mask.grey
+        /* CM_COLOR */
+        struct {
+            u_char red;
+#define red_mask   valid_mask.rgb_mask.red
+            u_char green;
+#define green_mask valid_mask.rgb_mask.green
+            u_char blue;
+#define blue_mask  valid_mask.rgb_mask.blue
+        } rgb_mask;
+    } valid_mask;
+    u_short first;	/* what color register does entry[0] refer to. */
+    u_short size;	/* number of entries */
+    u_long *entry;	/* the table of actual color values. */
+};
+
+enum colormap_type {
+    CM_MONO,		/* only on or off allowed */
+    CM_GREYSCALE,	/* grey vals. */
+    CM_COLOR		/* RGB vals. */
+};
+
+#define CM_FIXVAL(x) (0xff & (x))
+
+/* these macros are for creating entries */
+#define MAKE_COLOR_ENTRY(r,g,b) \
+    (CM_FIXVAL(r) << 16 | CM_FIXVAL(g) << 8 | CM_FIXVAL(b))
+#define MAKE_MONO_ENTRY(x)	((x) ? 1 : 0)
+#define MAKE_GREY_ENTRY(l)	CM_FIXVAL(l)
+
+#define CM_LTOW(v) \
+    (((0x000F0000 & (v)) >> 8) | ((0x00000F00 & (v)) >> 4) | (0xF & (v)))
+#define CM_WTOL(v) \
+    (((0xF00 & (v)) << 8) | ((0x0F0 & (v)) << 4) | (0xF & (v)))
+
+/*
+ * View stuff.
+ */
+typedef void remove_view_func (view_t *v);                               
+typedef void free_view_func (view_t *v);                               
+typedef void display_view_func (view_t *v);             
+typedef dmode_t *get_mode_func (view_t *v);    
+typedef int get_colormap_func (view_t *v, colormap_t *);
+typedef int use_colormap_func (view_t *v, colormap_t *);
+
+struct view {
+    bmap_t  *bitmap;			/* bitmap. */
+    box_t    display;			/* viewable area. */
+    void    *data;			/* view specific data. */
+
+    /* functions */
+    display_view_func *display_view;	/* make this view active */
+    remove_view_func  *remove_view;	/* remove this view if active */
+    free_view_func    *free_view;	/* free this view */
+    get_mode_func     *get_display_mode;/* get the mode this view belongs to */
+    get_colormap_func *get_colormap;	/* get a color map for registers */
+    use_colormap_func *use_colormap;	/* use color map to load registers */
+};
+
+#define VDISPLAY_LINE(v, p, l) ((v)->bitmap->plane[(p)] +\
+	(((v)->bitmap->bytes_per_row + (v)->bitmap->row_mod) * l))
+
+/*
+ * Mode stuff
+ */
+
+typedef view_t *alloc_view_func (dmode_t *mode, dimen_t *dim, u_char depth);
+typedef view_t *get_current_view_func (dmode_t *);
+typedef monitor_t  *get_monitor_func (dmode_t *);
+    
+struct display_mode {
+    LIST_ENTRY(display_mode) link;
+    u_char    *name;			/* logical name for mode. */
+    dimen_t    nominal_size;		/* best fit. */
+    void      *data;			/* mode specific flags. */
+    alloc_view_func       *alloc_view;	/* allocate a view for this mode. */
+    get_current_view_func *get_current_view;	/* get active view. */
+    get_monitor_func      *get_monitor;	/* get monitor that mode belongs to */
+};
+
+/*
+ * Monitor stuff.
+ */
+typedef void     vbl_handler_func (void *);
+typedef dmode_t *get_next_mode_func (dmode_t *);
+typedef dmode_t *get_current_mode_func (void);
+typedef dmode_t *get_best_mode_func (dimen_t *size, u_char depth);
+typedef bmap_t *alloc_bitmap_func (u_short w, u_short h, u_short d, u_short f);
+typedef void    free_bitmap_func (bmap_t *bm);
+
+struct monitor {
+    LIST_ENTRY(monitor) link; /* a link into the database. */
+    u_char     *name;	/* a logical name for this monitor. */
+    void       *data;	/* monitor specific data. */
+    get_current_mode_func *get_current_mode;
+    vbl_handler_func	*vbl_handler;	/* called on every vbl if not NULL */
+    get_next_mode_func	*get_next_mode;	/* return next mode in list */
+    get_best_mode_func	*get_best_mode; /* return mode that best fits */
+    
+    alloc_bitmap_func	*alloc_bitmap;
+    free_bitmap_func	*free_bitmap;
+};
+
+/*
+ * Misc draw related macros.
+ */
+
+#define BOX_2_RECT(b,r) do { \
+    (r)->left = (b)->x; (r)->top = (b)->y; \
+    (r)->right = (b)->x + (b)->width -1; \
+    (r)->bottom = (b)->y + (b)->height -1; \
+    } while (0)
+
+#define RECT_2_BOX(r,b) do { \
+    (b)->x = (r)->left; \
+    (b)->y = (r)->top; \
+    (b)->width = (r)->right - (r)->left +1; \
+    (b)->height = (r)->bottom - (r)->top +1; \
+    } while(0)
+
+#define INIT_BOX(b,xx,yy,ww,hh) do{(b)->x = xx; (b)->y = yy; (b)->width = ww; (b)->height = hh;}while (0)
+#define INIT_RECT(rc,l,t,r,b) do{(rc)->left = l; (rc)->right = r; (rc)->top = t; (rc)->bottom = b;}while (0)
+#define INIT_POINT(p,xx,yy) do {(p)->x = xx; (p)->y = yy;} while (0)
+#define INIT_DIM(d,w,h) do {(d)->width = w; (d)->height = h;} while (0)
+
+
+/*
+ * Prototypes
+ */
+
+#if defined (__STDC__)
+/* views */
+view_t * grf_alloc_view (dmode_t *d, dimen_t *dim, u_char depth);
+void grf_display_view (view_t *v);
+void grf_remove_view (view_t *v);
+void grf_free_view (view_t *v);
+dmode_t *grf_get_display_mode (view_t *v);
+int grf_get_colormap (view_t *v, colormap_t *cm);
+int grf_use_colormap (view_t *v, colormap_t *cm);
+/* modes */
+view_t *grf_get_current_view (dmode_t *d);
+monitor_t *grf_get_monitor (dmode_t *d);
+/* monitors */
+dmode_t * grf_get_next_mode (monitor_t *m, dmode_t *d);
+dmode_t * grf_get_current_mode (monitor_t *);
+dmode_t * grf_get_best_mode (monitor_t *m, dimen_t *size, u_char depth);
+bmap_t  * grf_alloc_bitmap (monitor_t *m, u_short w, u_short h, u_short d, u_short f);
+void grf_free_bitmap (monitor_t *m, bmap_t *bm);
+#endif /* __STDC__ */
+
+#endif /* _GRFABS_REG_H */