![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bitblt_apa16.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / new / X / libibm / bitblt|
Return to bitblt_apa16.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / X / libibm / bitblt |
1.1 root 1: #ifndef lint
2: static char *rcsid_bitblt_apa16_c = "$Header: bitblt_apa16.c,v 10.1 86/11/19 10:50:57 jg Exp $";
3: #endif lint
4: /*
5: * This file contains routines to do hardware bit block transfers (bitblt's)
6: * on the APA-16.
7: *
8: * Copyright (c) 1986 Brown University
9: *
10: * Permission to use, copy, modify and distribute this software and its
11: * documentation for any purpose and without fee is hereby granted, provided
12: * that the above copyright notice appear in all copies, and that both
13: * that copyright notice and this permission notice appear in supporting
14: * documentation, and that the name of Brown University not be used in
15: * advertising or publicity pertaining to distribution of the software without
16: * specific, written prior permission. Brown University makes no
17: * representations about the suitability of this software for any purpose.
18: * It is provided "as-is" without express or implied warranty.
19: *
20: * Written by Daniel Stone, Brown University/IRIS, April 23, 1986.
21: */
22:
23: #if (APA16 && USE_APA16_HDWR)
24:
25: #include "bitblt_int.h"
26: #include "bitblt_apa16.h"
27:
28: /*
29: * This array indicates whether or not the coorisponding combination rule
30: * can be done in hardware. A non-zero indicates the hardware can do it.
31: */
32: #define NO_FUNC 0
33:
34: unsigned short execute_cmd[32] = {
35: BUILD_EXCMD(DECR_QUE_COUNT,ROT_WRDST,LF_CLEAR), /* DstClear 0 */
36: BUILD_EXCMD(DECR_QUE_COUNT,ROT_RECTCP,LF_DSTandSRC),/* SrcAnd 1 */
37: BUILD_EXCMD(DECR_QUE_COUNT,ROT_RECTCP,LF_NotDSTandSRC),/*SrcAndNotDst2*/
38: BUILD_EXCMD(DECR_QUE_COUNT,ROT_RECTCP,LF_COPYSRC), /* SrcCopy 3 */
39: BUILD_EXCMD(DECR_QUE_COUNT,ROT_RECTCP,LF_DSTandNotSRC),/* NotSrcAnd 4 */
40: NO_FUNC, /* DstCopy 5 */
41: BUILD_EXCMD(DECR_QUE_COUNT,ROT_RECTCP,LF_DSTxorSRC), /* SrcXor 6 */
42: BUILD_EXCMD(DECR_QUE_COUNT,ROT_RECTCP,LF_DSTorSRC), /* SrcOr 7 */
43: NO_FUNC, /* NotSrcAndNotDst 8 */
44: NO_FUNC, /* NotSrcXor 9 */
45: BUILD_EXCMD(DECR_QUE_COUNT,ROT_WRDST,LF_NotDST), /*NotDstCopy 10*/
46: NO_FUNC, /* SrcOrNotDst 11*/
47: NO_FUNC, /* NotSrcCopy 12 */
48: NO_FUNC, /* NotSrcOr 13 */
49: BUILD_EXCMD(DECR_QUE_COUNT,ROT_RECTCP,LF_NotDSTorNotSRC),
50: /* NotSrcOrNotDst 14*/
51: BUILD_EXCMD(DECR_QUE_COUNT,ROT_WRDST,LF_SET), /* DstSet 15 */
52: BUILD_EXCMD(DECR_QUE_COUNT,ROT_WRDST,LF_CLEAR),/* TileDstClear 16 */
53: NO_FUNC, /* TileAnd 17 */
54: NO_FUNC, /* TileAndNotDst 18 */
55: NO_FUNC, /* TileCopy 19 */
56: NO_FUNC, /* NotTileAnd 20 */
57: NO_FUNC, /* TileDstCopy 21 */
58: NO_FUNC, /* TileXor 22 */
59: NO_FUNC, /* TileOr 23 */
60: NO_FUNC, /* NotTileAndNotDst 24 */
61: NO_FUNC, /* NotTileXor 25 */
62: BUILD_EXCMD(DECR_QUE_COUNT,ROT_WRDST,LF_NotDST),/*TileNotDstCopy 26 */
63: NO_FUNC, /* TileOrNotDst 27 */
64: NO_FUNC, /* NotTileCopy 28 */
65: NO_FUNC, /* NotTileOr 29 */
66: NO_FUNC, /* NotTileOrNotDst 30 */
67: BUILD_EXCMD(DECR_QUE_COUNT,ROT_WRDST,LF_SET),/* TileDstSet 31 */
68: };
69:
70: /*
71: * Set up hardware to do screen to screen copy then do it.
72: * Returns 1 if the hardware couldn't handle it (should never happen) and 0
73: * if the blt was successful.
74: */
75: apa16_StoS(sv)
76: register Blt_sysdata *sv; /* System variables */
77: {
78: register unsigned short *Qptr = (unsigned short *)LAST_QUE_APA16BASE;
79: register tmp; /* just a garbage register */
80: int c;
81:
82: /*
83: * Check the destination and source bitmap pointers to the screen.
84: * If they are different than the start address of the screen then
85: * offset each rectangle.
86: */
87: if (sv->dst.data > (unsigned short *)APA16BASE) {
88: /*
89: * Take apart the address. Note the address is in bytes
90: * corner_x is in bits so it must be multiplied by 8.
91: */
92: sv->dst.rect.corner_x += (((long)sv->dst.data & 0x7F) << 3);
93: sv->dst.rect.corner_y += (((long)sv->dst.data & 0x7FF80) >> 7);
94: }
95:
96: if (sv->src.data > (unsigned short *)APA16BASE) {
97: /*
98: * Take apart the address. Note the address is in bytes
99: * corner_x is in bits so it must be multiplied by 8.
100: */
101: sv->src.rect.corner_x += (((long)sv->src.data & 0x7F) << 3);
102: sv->src.rect.corner_y += (((long)sv->src.data & 0x7FF80) >> 7);
103: }
104:
105: /*
106: * Wait for the previous command to finish.
107: */
108: WAIT_QUE(c,sv->rule);
109:
110: /*
111: * Load the the instructions that tell the queue command
112: * processor to load:
113: * - The X and Y destination registers with the bottom
114: * right corner of the screen area where the
115: * destination rectangle resides.
116: *
117: * - The X and Y source registers with the bottom right
118: * corner of the source screen area.
119: *
120: * - The destination width and height registers with the
121: * width and height of the rectangle to be moved.
122: *
123: * Then load an execute command instruction with one of the copy source
124: * logic functions and a Raster Operation Type (ROT) of copy screen
125: * to screen.
126: */
127: *Qptr-- = BUILD_REGLOAD(XDST_REG,sv->dst.rect.corner_x+1);
128: *Qptr-- = BUILD_REGLOAD(RECT_YDST_REG,sv->dst.rect.corner_y+1);
129: *Qptr-- = BUILD_REGLOAD(XSRC_REG,sv->src.rect.corner_x+1);
130: *Qptr-- = BUILD_REGLOAD(YSRC_REG,sv->src.rect.corner_y+1);
131: *Qptr-- = BUILD_REGLOAD(WIDTH_REG,(sv->width & 1023));
132: *Qptr-- = BUILD_REGLOAD(RECT_HEIGHT_REG,(sv->height & 1023));
133: *Qptr = execute_cmd[sv->rule];
134:
135: *QUE_PTR_R = SPTR_TO_QPTR(LAST_QUE_APA16BASE);
136:
137: INCR_QUE_COUNT(tmp);
138: return(0);
139: }
140:
141: #ifdef notdef
142: /*
143: * Set up hardware to do memory to screen copy then do it.
144: * Returns 1 if the hardware couldn't handle it (should never happen) and
145: * 0 if the blt was successful.
146: */
147: apa16_MtoS(sv)
148: register Blt_sysdata *sv; /* System variables */
149: {
150: register unsigned short *Qptr = (unsigned short *)LAST_QUE_APA16BASE;
151: register tmp; /* just a garbage register */
152: int c;
153:
154: /*
155: * Wait for the previous command to finish.
156: */
157: WAIT_QUE(c,sv->rule);
158:
159: /*
160: * Load the the instructions that tell the queue command
161: * processor to load:
162: * - The high,middle and low bytes of the source address into
163: * the APA-16 hardware registers.
164: *
165: * - The starting bit of the starting source word.
166: *
167: * - The number of shorts needed to increment the destination
168: * pointer to the next scanline.
169: *
170: * - The X and Y destination corner points plus 1 because
171: * it uses these points exclusively.
172: *
173: * - The destination width and height registers with the
174: * width and height of the rectangle to be moved.
175: *
176: * Then load an execute command instruction with one of the copy source
177: * logic functions and a Raster Operation Type (ROT) of memory to
178: * screen (TDMA).
179: */
180: *Qptr-- = BUILD_REGLOAD(REG_HIGHBYTE,HIGH_BYTE(sv->src.data));
181: *Qptr-- = BUILD_REGLOAD(REG_LOWBYTE,MID_BYTE(sv->src.data));
182: *Qptr-- = BUILD_REGLOAD(REG_Y_SRC,LOW_BYTE(sv->src.data));
183:
184: *Qptr-- = BUILD_REGLOAD(REG_GEN_B,MOD_BPW(sv->src.rect.origin_x));
185: *Qptr-- = BUILD_REGLOAD(REG_GEN_A,sv->src.nextline);
186:
187: *Qptr-- = BUILD_REGLOAD(REG_X_DST,sv->dst.rect.corner_x+1);
188: *Qptr-- = BUILD_REGLOAD(REG_Y_DST,sv->dst.rect.corner_y+1);
189:
190: *Qptr-- = BUILD_REGLOAD(REG_X_SRC,(sv->width & 1023));
191: *Qptr-- = BUILD_REGLOAD(REG_Y_LOOP,(sv->height & 1023));
192:
193: /*
194: * This HACK works, but only because ROT_TDDMA has all the bits
195: * on anyway. To do this right one would do:
196: * (execute_cmd[sv->rule] & 0x03f0) | 0x03f0
197: */
198: *Qptr = (execute_cmd[sv->rule] | ROT_TDDMA);
199:
200: /*
201: * Set up the queue pointer register and execute the command.
202: */
203: *QUE_PTR_R = SPTR_TO_QPTR(LAST_QUE_APA16BASE);
204:
205: /*
206: * I think I have to enable DMA first.
207: */
208: ENABLE_DMA_PROC(tmp);
209: INCR_QUE_COUNT(tmp);
210:
211: return(0);
212: }
213: #endif notdef
214:
215: /*
216: * Depending on the tile rule, copy the tile to the hidden area of the
217: * screen and then set up a string of queue commands to move the tile to the
218: * screen.
219: */
220: apa16_copyTile(sv)
221: register Blt_sysdata *sv; /* System variables */
222: {
223: register unsigned short *Qptr = (unsigned short *)LAST_QUE_APA16BASE;
224: register tmp; /* just a garbage register */
225: int c;
226:
227: /*
228: * Wait for the previous command to finish.
229: */
230: WAIT_QUE(c,sv->rule);
231:
232: /*
233: * Check and see if this tile combination rule is a destination only
234: * rule like DstClear, TileDstClear, NotDstCopy, TileNotDstCopy,
235: * DstSet, TileDstSet.
236: */
237: if (IS_ROT_WRDST(execute_cmd[sv->rule])) {
238: *Qptr-- = BUILD_REGLOAD(XDST_REG,sv->dst.rect.corner_x+1);
239: *Qptr-- = BUILD_REGLOAD(YDST_REG,sv->dst.rect.corner_y+1);
240: *Qptr-- = BUILD_REGLOAD(WIDTH_REG,(sv->width & 1023));
241: *Qptr-- = BUILD_REGLOAD(HEIGHT_REG,(sv->height & 1023));
242: *Qptr = execute_cmd[sv->rule];
243:
244: /*
245: * Set up the queue pointer register and execute the command.
246: */
247: *QUE_PTR_R = SPTR_TO_QPTR(LAST_QUE_APA16BASE);
248:
249: INCR_QUE_COUNT(tmp);
250: }
251: else {
252: /*
253: * Must copy the tile to the hidden area of the screen
254: * and then setup a series of que commands to copy it to
255: * the screen.
256: */
257: return(1);
258: }
259:
260: return(0);
261: }
262: #endif APA16 && USE_APA16_HDWR
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.