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
rgb524setrs2(void)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
rgb524xo(int index,uchar data)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
rgb524disable(VGAscr *)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
rgb524enable(VGAscr *)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
rgb524load(VGAscr *,Cursor * curs)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
rgb524move(VGAscr *,Point p)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 };
238