Subversion Repositories planix.SVN

Rev

Rev 2 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
2 - 1 
#include "u.h"
2 
#include "../port/lib.h"
3 
#include "mem.h"
4 
#include "dat.h"
5 
#include "fns.h"
6 
#include "io.h"
7 
#include "../port/error.h"
8 
 
9 
#define	Image	IMAGE
10 
#include <draw.h>
11 
#include <memdraw.h>
12 
#include <cursor.h>
13 
#include "screen.h"
14 
 
15 
/*
16 
 * IBM RGB524.
17 
 * 170/220MHz High Performance Palette DAC.
18 
 *
19 
 * Assumes hooked up to an S3 Vision96[48].
20 
 */
21 
enum {
22 
	IndexLo		= 0x00,
23 
	IndexHi		= 0x01,
24 
	Data		= 0x02,
25 
	IndexCtl	= 0x03,
26 
};
27 
 
28 
enum {						/* index registers */
29 
	CursorCtl	= 0x30,
30 
	CursorXLo	= 0x31,
31 
	CursorXHi	= 0x32,
32 
	CursorYLo	= 0x33,
33 
	CursorYHi	= 0x34,
34 
	CursorHotX	= 0x35,
35 
	CursorHotY	= 0x36,
36 
 
37 
	CursorR1	= 0x40,
38 
	CursorG1	= 0x41,
39 
	CursorB1	= 0x42,
40 
	CursorR2	= 0x43,
41 
	CursorG2	= 0x44,
42 
	CursorB2	= 0x45,
43 
	CursorR3	= 0x46,
44 
	CursorG3	= 0x47,
45 
	CursorB3	= 0x48,
46 
 
47 
	CursorArray	= 0x100,
48 
};
49 
 
50 
/*
51 
 * Lower 2-bits of indirect DAC register
52 
 * addressing.
53 
 */
54 
static ushort dacxreg[4] = {
55 
	PaddrW, Pdata, Pixmask, PaddrR
56 
};
57 
 
58 
static uchar
59 
rgb524setrs2(void)
60 
{
61 
	uchar rs2;
62 
 
63 
	rs2 = vgaxi(Crtx, 0x55);
64 
	vgaxo(Crtx, 0x55, (rs2 & 0xFC)|0x01);
65 
 
66 
	return rs2;
67 
}
68 
 
69 
static void
70 
rgb524xo(int index, uchar data)
71 
{
72 
	vgao(dacxreg[IndexLo], index & 0xFF);
73 
	vgao(dacxreg[IndexHi], (index>>8) & 0xFF);
74 
	vgao(dacxreg[Data], data);
75 
}
76 
 
77 
static void
78 
rgb524disable(VGAscr*)
79 
{
80 
	uchar rs2;
81 
 
82 
	rs2 = rgb524setrs2();
83 
	rgb524xo(CursorCtl, 0x00);
84 
	vgaxo(Crtx, 0x55, rs2);
85 
}
86 
 
87 
static void
88 
rgb524enable(VGAscr*)
89 
{
90 
	uchar rs2;
91 
 
92 
	rs2 = rgb524setrs2();
93 
 
94 
	/*
95 
	 * Make sure cursor is off by initialising the cursor
96 
	 * control to defaults.
97 
	 */
98 
	rgb524xo(CursorCtl, 0x00);
99 
 
100 
	/*
101 
	 * Cursor colour 1 (white),
102 
	 * cursor colour 2 (black).
103 
	 */
104 
	rgb524xo(CursorR1, Pwhite); rgb524xo(CursorG1, Pwhite); rgb524xo(CursorB1, Pwhite);
105 
	rgb524xo(CursorR2, Pblack); rgb524xo(CursorG2, Pblack); rgb524xo(CursorB2, Pblack);
106 
 
107 
	/*
108 
	 * Enable the cursor, 32x32, mode 2.
109 
	 */
110 
	rgb524xo(CursorCtl, 0x23);
111 
 
112 
	vgaxo(Crtx, 0x55, rs2);
113 
}
114 
 
115 
static void
116 
rgb524load(VGAscr*, Cursor* curs)
117 
{
118 
	uchar p, p0, p1, rs2;
119 
	int x, y;
120 
 
121 
	rs2 = rgb524setrs2();
122 
 
123 
	/*
124 
	 * Make sure cursor is off by initialising the cursor
125 
	 * control to defaults.
126 
	 */
127 
	rgb524xo(CursorCtl, 0x00);
128 
 
129 
	/*
130 
	 * Set auto-increment mode for index-register addressing
131 
	 * and initialise the cursor array index.
132 
	 */
133 
	vgao(dacxreg[IndexCtl], 0x01);
134 
	vgao(dacxreg[IndexLo], CursorArray & 0xFF);
135 
	vgao(dacxreg[IndexHi], (CursorArray>>8) & 0xFF);
136 
 
137 
	/*
138 
	 * Initialise the 32x32 cursor RAM array. There are 2 planes,
139 
	 * p0 and p1. Data is written 4 pixels per byte, with p1 the
140 
	 * MS bit of each pixel.
141 
	 * The cursor is set in X-Windows mode which gives the following
142 
	 * truth table:
143 
	 *	p1 p0	colour
144 
	 *	 0  0	underlying pixel colour
145 
	 *	 0  1	underlying pixel colour
146 
	 *	 1  0	cursor colour 1
147 
	 *	 1  1	cursor colour 2
148 
	 * Put the cursor into the top-left of the 32x32 array.
149 
	 */
150 
	for(y = 0; y < 32; y++){
151 
		for(x = 0; x < 32/8; x++){
152 
			if(x < 16/8 && y < 16){
153 
				p0 = curs->clr[x+y*2];
154 
				p1 = curs->set[x+y*2];
155 
 
156 
				p = 0x00;
157 
				if(p1 & 0x80)
158 
					p |= 0xC0;
159 
				else if(p0 & 0x80)
160 
					p |= 0x80;
161 
				if(p1 & 0x40)
162 
					p |= 0x30;
163 
				else if(p0 & 0x40)
164 
					p |= 0x20;
165 
				if(p1 & 0x20)
166 
					p |= 0x0C;
167 
				else if(p0 & 0x20)
168 
					p |= 0x08;
169 
				if(p1 & 0x10)
170 
					p |= 0x03;
171 
				else if(p0 & 0x10)
172 
					p |= 0x02;
173 
				vgao(dacxreg[Data], p);
174 
 
175 
				p = 0x00;
176 
				if(p1 & 0x08)
177 
					p |= 0xC0;
178 
				else if(p0 & 0x08)
179 
					p |= 0x80;
180 
				if(p1 & 0x04)
181 
					p |= 0x30;
182 
				else if(p0 & 0x04)
183 
					p |= 0x20;
184 
				if(p1 & 0x02)
185 
					p |= 0x0C;
186 
				else if(p0 & 0x02)
187 
					p |= 0x08;
188 
				if(p1 & 0x01)
189 
					p |= 0x03;
190 
				else if(p0 & 0x01)
191 
					p |= 0x02;
192 
				vgao(dacxreg[Data], p);
193 
			}
194 
			else{
195 
				vgao(dacxreg[Data], 0x00);
196 
				vgao(dacxreg[Data], 0x00);
197 
			}
198 
		}
199 
	}
200 
 
201 
	/*
202 
	 * Initialise the cursor hotpoint,
203 
	 * enable the cursor and restore state.
204 
	 */
205 
	rgb524xo(CursorHotX, -curs->offset.x);
206 
	rgb524xo(CursorHotY, -curs->offset.y);
207 
 
208 
	rgb524xo(CursorCtl, 0x23);
209 
 
210 
	vgaxo(Crtx, 0x55, rs2);
211 
}
212 
 
213 
static int
214 
rgb524move(VGAscr*, Point p)
215 
{
216 
	uchar rs2;
217 
 
218 
	rs2 = rgb524setrs2();
219 
 
220 
	rgb524xo(CursorXLo, p.x & 0xFF);
221 
	rgb524xo(CursorXHi, (p.x>>8) & 0x0F);
222 
	rgb524xo(CursorYLo, p.y & 0xFF);
223 
	rgb524xo(CursorYHi, (p.y>>8) & 0x0F);
224 
 
225 
	vgaxo(Crtx, 0x55, rs2);
226 
 
227 
	return 0;
228 
}
229 
 
230 
VGAcur vgargb524cur = {
231 
	"rgb524hwgc",
232 
 
233 
	rgb524enable,
234 
	rgb524disable,
235 
	rgb524load,
236 
	rgb524move,
237 
};