Rev 54 | Details | Compare with Previous | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
54 | pj | 1 | /* |
2 | * sierra.c: |
||
3 | * |
||
4 | * RAMDAC definition for basic Sierra, SC15025 and SC1148x. |
||
5 | */ |
||
6 | |||
7 | #include <stdlib.h> |
||
8 | #include <stdio.h> |
||
9 | #include "libvga.h" |
||
10 | |||
11 | #include "timing.h" |
||
12 | #include "vgaregs.h" |
||
13 | #include "driver.h" /* for __svgalib_driver_report */ |
||
14 | #include "ramdac.h" |
||
15 | |||
16 | /* |
||
17 | * RAMDAC definition for basic Sierra-type DAC |
||
18 | * that can do 32K (5-5-5) color mode (16bpp) with doubled VCLK. |
||
19 | * A value of 0x80 is written to the Hidden DAC register for this mode. |
||
20 | */ |
||
21 | |||
22 | #ifdef INCLUDE_SIERRA_DAC_TEST |
||
23 | static int Sierra_32K_probe(void) |
||
24 | { |
||
25 | /* Should return 1 for any Sierra-type DAC. */ |
||
26 | return 0; |
||
27 | } |
||
28 | #else |
||
29 | #define Sierra_32K_probe 0 |
||
30 | #endif |
||
31 | |||
32 | #ifdef INCLUDE_SIERRA_DAC |
||
33 | static void Sierra_32K_init(void) |
||
34 | { |
||
35 | /* Should probe the exact DAC type. */ |
||
36 | if (__svgalib_driver_report) |
||
81 | giacomo | 37 | cprintf("svgalib: Using Sierra 32K DAC.\n"); |
54 | pj | 38 | } |
39 | |||
40 | static int Sierra_32K_map_clock(int bpp, int pixelclock) |
||
41 | { |
||
42 | if (bpp == 16) |
||
43 | return pixelclock * 2; |
||
44 | return pixelclock; |
||
45 | } |
||
46 | |||
47 | static int Sierra_32K_map_horizontal_crtc(int bpp, int pixelclock, int htiming) |
||
48 | { |
||
49 | if (bpp == 16) |
||
50 | return htiming * 2; |
||
51 | return htiming; |
||
52 | } |
||
53 | #endif |
||
54 | |||
55 | #if defined(INCLUDE_SIERRA_DAC) || defined(INCLUDE_ICW_DAC) || \ |
||
56 | defined(INCLUDE_ATT20C490_DAC) || defined(INCLUDE_ATT20C498_DAC) |
||
57 | void __svgalib_Sierra_32K_savestate(unsigned char *regs) |
||
58 | { |
||
59 | _ramdac_dactocomm(); |
||
60 | regs[0] = inb(PEL_MSK); |
||
61 | } |
||
62 | |||
63 | void __svgalib_Sierra_32K_restorestate(const unsigned char *regs) |
||
64 | { |
||
65 | _ramdac_dactocomm(); |
||
66 | outb(PEL_MSK, regs[0]); |
||
67 | } |
||
68 | |||
69 | #endif |
||
70 | |||
71 | #ifdef INCLUDE_SIERRA_DAC |
||
72 | static void Sierra_32K_initializestate(unsigned char *regs, int bpp, int colormode, |
||
73 | int pixelclock) |
||
74 | { |
||
75 | regs[0] = 0; |
||
76 | if (colormode == RGB16_555) |
||
77 | regs[0] = 0x80; |
||
78 | } |
||
79 | |||
80 | static void Sierra_32K_qualify_cardspecs(CardSpecs * cardspecs, int dacspeed) |
||
81 | { |
||
82 | dacspeed = __svgalib_setDacSpeed(dacspeed, 80000); |
||
83 | cardspecs->maxPixelClock4bpp = dacspeed; |
||
84 | cardspecs->maxPixelClock8bpp = dacspeed; |
||
85 | cardspecs->maxPixelClock16bpp = dacspeed / 2; |
||
86 | cardspecs->maxPixelClock24bpp = 0; |
||
87 | cardspecs->maxPixelClock32bpp = 0; |
||
88 | cardspecs->mapClock = Sierra_32K_map_clock; |
||
89 | cardspecs->mapHorizontalCrtc = Sierra_32K_map_horizontal_crtc; |
||
90 | cardspecs->flags |= NO_RGB16_565; |
||
91 | } |
||
92 | |||
93 | DacMethods __svgalib_Sierra_32K_methods = |
||
94 | { |
||
95 | SIERRA_32K, |
||
96 | "Sierra 32K colors VGA DAC", |
||
97 | 0, |
||
98 | Sierra_32K_probe, |
||
99 | Sierra_32K_init, |
||
100 | Sierra_32K_qualify_cardspecs, |
||
101 | __svgalib_Sierra_32K_savestate, |
||
102 | __svgalib_Sierra_32K_restorestate, |
||
103 | Sierra_32K_initializestate, |
||
104 | 1 /* State size. */ |
||
105 | }; |
||
106 | #endif |
||
107 | |||
108 | |||
109 | /* |
||
110 | * RAMDAC definition for Sierra 15025/26 |
||
111 | */ |
||
112 | |||
113 | #ifdef INCLUDE_SC15025_DAC_TEST |
||
114 | static unsigned char SC15025_Rev; |
||
115 | |||
116 | static int SC15025_probe(void) |
||
117 | { |
||
118 | unsigned char c, id[4]; |
||
119 | int i, flag = 0; |
||
120 | |||
121 | _ramdac_dactocomm(); |
||
122 | c = inb(PEL_MSK); |
||
123 | _ramdac_setcomm(c | 0x10); |
||
124 | for (i = 0; i < 4; i++) { |
||
125 | outb(PEL_IR, 0x9 + i); |
||
126 | id[i] = inb(PEL_IW); |
||
127 | } |
||
128 | _ramdac_setcomm(c); |
||
129 | _ramdac_dactopel(); |
||
130 | if (id[0] == 'S' && /* Sierra */ |
||
131 | ((id[1] << 8) | id[2]) == 15025) { /* unique for the SC 15025/26 */ |
||
132 | flag = 1; |
||
133 | SC15025_Rev = id[3]; |
||
134 | } |
||
135 | return flag; |
||
136 | } |
||
137 | #else |
||
138 | #define SC15025_probe 0 |
||
139 | #define SC15025_Rev ' ' |
||
140 | #endif |
||
141 | |||
142 | #ifdef INCLUDE_SC15025_DAC |
||
143 | static void SC15025_init(void) |
||
144 | { |
||
145 | if (__svgalib_driver_report) |
||
81 | giacomo | 146 | cprintf("svgalib: Using Sierra 15025/26%c truecolor DAC.\n", SC15025_Rev); |
54 | pj | 147 | } |
148 | |||
149 | static void SC15025_initializestate(unsigned char *regs, int bpp, int colormode, |
||
150 | int pixelclock) |
||
151 | { |
||
152 | regs[0] = 0; |
||
153 | regs[1] = 0; |
||
154 | regs[2] = 0; |
||
155 | if (colormode == RGB16_555) { |
||
156 | regs[0] = 0x80; |
||
157 | regs[1] = 1; |
||
158 | } else if (colormode == RGB16_565) { |
||
159 | regs[0] = 0xC0; |
||
160 | regs[1] = 1; |
||
161 | } else if (colormode == RGB32_888_B) { |
||
162 | regs[0] = 0x40; |
||
163 | regs[1] = 1; |
||
164 | regs[2] = 1; |
||
165 | } |
||
166 | /* ARI: FIXME: regs[1] should be 1 for CLUT8_8 */ |
||
167 | /* also: OR 8 to regs[0] to enable gamma correction */ |
||
168 | } |
||
169 | |||
170 | static void SC15025_savestate(unsigned char *regs) |
||
171 | { |
||
172 | _ramdac_dactocomm(); |
||
173 | regs[0] = inb(PEL_MSK); |
||
174 | _ramdac_setcomm(regs[0] | 0x10); |
||
175 | _ramdac_dactocomm(); |
||
176 | outb(PEL_IR, 8); |
||
177 | regs[1] = inb(PEL_IW); /* Aux control */ |
||
178 | outb(PEL_IR, 16); |
||
179 | regs[2] = inb(PEL_IW); /* Pixel Repack */ |
||
180 | _ramdac_setcomm(regs[0]); |
||
181 | } |
||
182 | |||
183 | static void SC15025_restorestate(const unsigned char *regs) |
||
184 | { |
||
185 | unsigned char c; |
||
186 | |||
187 | _ramdac_dactocomm(); |
||
188 | c = inb(PEL_MSK); |
||
189 | _ramdac_setcomm(c | 0x10); |
||
190 | _ramdac_dactocomm(); |
||
191 | outb(PEL_IR, 8); |
||
192 | outb(PEL_IW, regs[1]); /* Aux control */ |
||
193 | outb(PEL_IR, 16); |
||
194 | outb(PEL_IW, regs[2]); /* Pixel Repack */ |
||
195 | _ramdac_setcomm(c); |
||
196 | _ramdac_setcomm(regs[0]); |
||
197 | } |
||
198 | |||
199 | static int SC15025_map_clock(int bpp, int pixelclock) |
||
200 | { |
||
201 | if (bpp == 32) |
||
202 | return pixelclock * 2; |
||
203 | return pixelclock; |
||
204 | } |
||
205 | |||
206 | static int SC15025_map_horizontal_crtc(int bpp, int pixelclock, int htiming) |
||
207 | { |
||
208 | if (bpp == 16) |
||
209 | return htiming * 2; |
||
210 | if (bpp == 32) |
||
211 | return htiming * 4; |
||
212 | return htiming; |
||
213 | } |
||
214 | |||
215 | static void SC15025_qualify_cardspecs(CardSpecs * cardspecs, int dacspeed) |
||
216 | { |
||
217 | dacspeed = __svgalib_setDacSpeed(dacspeed, 110000); |
||
218 | cardspecs->maxPixelClock4bpp = dacspeed; |
||
219 | cardspecs->maxPixelClock8bpp = dacspeed; |
||
220 | cardspecs->maxPixelClock16bpp = dacspeed / 2; |
||
221 | cardspecs->maxPixelClock24bpp = 0; |
||
222 | cardspecs->maxPixelClock32bpp = dacspeed / 3; |
||
223 | cardspecs->mapClock = SC15025_map_clock; |
||
224 | cardspecs->mapHorizontalCrtc = SC15025_map_horizontal_crtc; |
||
225 | } |
||
226 | |||
227 | DacMethods __svgalib_SC15025_methods = |
||
228 | { |
||
229 | SIERRA_15025, |
||
230 | "Sierra SC15025/6 DAC", |
||
231 | 0, |
||
232 | SC15025_probe, |
||
233 | SC15025_init, |
||
234 | SC15025_qualify_cardspecs, |
||
235 | SC15025_savestate, |
||
236 | SC15025_restorestate, |
||
237 | SC15025_initializestate, |
||
238 | 3 /* State size. */ |
||
239 | }; |
||
240 | #endif |
||
241 | |||
242 | /* |
||
243 | * RAMDAC definition for Sierra 1148x Series. |
||
244 | * 11482, 83, and 84 (Mark 2) can do 32K (5-5-5) color mode (16bpp). |
||
245 | * 11485, 87, and 89 (Mark 3) additionally can do 64K (5-6-5) color mode, |
||
246 | * but are not autodetected since they cannot be distinguished from Mark 2. |
||
247 | * 11486 really is a Sierra 32K dac, and should have been set by user. |
||
248 | * |
||
249 | * Note that these dacs are different from 'Sierra 32K', since they can be |
||
250 | * detected as such, while there are clones that work compatible to the |
||
251 | * Sierra dacs, but cannot be autodetected. To avoid such dacs to fail |
||
252 | * the type 'Sierra 32K' still refers to them, while this new type |
||
253 | * 'SC1148x Series' refers to original Sierra dacs. |
||
254 | * |
||
255 | * ATTENTION: THIS TEST MUST BE LAST IN CHAIN, SINCE MANY BETTER DACS |
||
256 | * IMPLEMENT 32K MODES COMPATIBLE TO THIS ONE AND WOULD BE DETECTED AS |
||
257 | * SIERRA! |
||
258 | * |
||
259 | */ |
||
260 | |||
261 | #ifdef INCLUDE_SC1148X_DAC_TEST |
||
262 | static int SC1148X_probe(void) |
||
263 | { |
||
264 | unsigned char oc, op, tmp, tmp2; |
||
265 | int flag = 0; |
||
266 | |||
267 | _ramdac_dactopel(); |
||
268 | tmp = inb(PEL_MSK); |
||
269 | do { |
||
270 | tmp2 = tmp; |
||
271 | tmp = inb(PEL_MSK); |
||
272 | } while (tmp2 != tmp); |
||
273 | inb(PEL_IW); |
||
274 | inb(PEL_MSK); |
||
275 | inb(PEL_MSK); |
||
276 | inb(PEL_MSK); |
||
277 | for (tmp2 = 9; tmp != 0x8E && tmp2 > 0; tmp2--) |
||
278 | tmp = inb(PEL_MSK); |
||
279 | if (tmp != 0x8E) { |
||
280 | _ramdac_dactocomm(); |
||
281 | oc = inb(PEL_MSK); |
||
282 | _ramdac_dactopel(); |
||
283 | op = inb(PEL_MSK); |
||
284 | tmp = oc ^ 0xFF; |
||
285 | outb(PEL_MSK, tmp); |
||
286 | _ramdac_dactocomm(); |
||
287 | tmp2 = inb(PEL_MSK); |
||
288 | if (tmp2 != tmp) { |
||
289 | tmp = _ramdac_setcomm(tmp = oc ^ 0x60); |
||
290 | if ((tmp & 0xe0) == (tmp2 & 0xe0)) { |
||
291 | tmp = inb(PEL_MSK); |
||
292 | _ramdac_dactopel(); |
||
293 | if (tmp != inb(PEL_MSK)) |
||
294 | flag = 1; /* Sierra Mark 2 or 3 */ |
||
295 | } else { |
||
296 | /* We have a Sierra SC11486 */ |
||
297 | #ifdef INCLUDE_SIERRA_DAC |
||
298 | flag = 1; |
||
299 | /* We do some ugly trickery here to patch SC1148X Series |
||
300 | descriptor with values from Sierra 32K descriptor, since |
||
301 | this is what whe really have detected! */ |
||
302 | __svgalib_SC1148X_methods.id = SIERRA_32K; |
||
303 | __svgalib_SC1148X_methods.name = __svgalib_Sierra_32K_methods.name; |
||
304 | __svgalib_SC1148X_methods.initialize = __svgalib_Sierra_32K_methods.initialize; |
||
305 | __svgalib_SC1148X_methods.qualifyCardSpecs = __svgalib_Sierra_32K_methods.qualifyCardSpecs ; |
||
306 | __svgalib_SC1148X_methods.initializeState = __svgalib_Sierra_32K_methods.initializeState ; |
||
307 | #endif |
||
308 | } |
||
309 | _ramdac_dactocomm(); |
||
310 | outb(PEL_MSK, oc); |
||
311 | } |
||
312 | _ramdac_dactopel(); |
||
313 | outb(PEL_MSK, op); |
||
314 | } else { |
||
315 | _ramdac_dactopel(); |
||
316 | /* Diamond SS2410 */ |
||
317 | } |
||
318 | return flag; |
||
319 | } |
||
320 | #else |
||
321 | #define SC1148x_probe 0 |
||
322 | #endif |
||
323 | |||
324 | #ifdef INCLUDE_SC1148X_DAC |
||
325 | static void SC1148X_init(void) |
||
326 | { |
||
327 | if (__svgalib_driver_report) |
||
81 | giacomo | 328 | cprintf("svgalib: Using Sierra 1148x series 32K DAC.\n"); |
54 | pj | 329 | } |
330 | |||
331 | static void SC1148X_initializestate(unsigned char *regs, int bpp, int colormode, |
||
332 | int pixelclock) |
||
333 | { |
||
334 | regs[0] = 0; |
||
335 | if (colormode == RGB16_555) |
||
336 | regs[0] = 0xA0; |
||
337 | /* Mark 3 (not autodetected) */ |
||
338 | else if (colormode == RGB16_565) |
||
339 | regs[0] = 0xE0; |
||
340 | } |
||
341 | |||
342 | static void SC1148X_qualify_cardspecs(CardSpecs * cardspecs, int dacspeed) |
||
343 | { |
||
344 | dacspeed = __svgalib_setDacSpeed(dacspeed, 110000); |
||
345 | cardspecs->maxPixelClock4bpp = dacspeed; |
||
346 | cardspecs->maxPixelClock8bpp = dacspeed; |
||
347 | cardspecs->maxPixelClock16bpp = dacspeed / 2; |
||
348 | cardspecs->maxPixelClock24bpp = 0; |
||
349 | cardspecs->maxPixelClock32bpp = 0; |
||
350 | cardspecs->mapClock = Sierra_32K_map_clock; |
||
351 | cardspecs->mapHorizontalCrtc = Sierra_32K_map_horizontal_crtc; |
||
352 | cardspecs->flags |= NO_RGB16_565; /* Mark 3 (11485,87, and higher) can */ |
||
353 | } |
||
354 | |||
355 | DacMethods __svgalib_SC1148X_methods = |
||
356 | { |
||
357 | SIERRA_1148X, |
||
358 | "Sierra SC1148x series 32K colors VGA DAC", |
||
359 | 0, |
||
360 | SC1148X_probe, |
||
361 | SC1148X_init, |
||
362 | SC1148X_qualify_cardspecs, |
||
363 | __svgalib_Sierra_32K_savestate, |
||
364 | __svgalib_Sierra_32K_restorestate, |
||
365 | SC1148X_initializestate, |
||
366 | 1 /* State size. */ |
||
367 | }; |
||
368 | #endif |