?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Expand PMF_FN_* macros.
[netbsd-mini2440.git] / sys / arch / amiga / dev / grf_et.c
blobeba0095016c1c50038d55b39d6eb2fe7c9a87d62
1 /* $NetBSD: grf_et.c,v 1.27 2009/03/18 17:06:42 cegger Exp $ */
2
3 /*
4 * Copyright (c) 1997 Klaus Burkert
5 * Copyright (c) 1996 Tobias Abt
6 * Copyright (c) 1995 Ezra Story
7 * Copyright (c) 1995 Kari Mettinen
8 * Copyright (c) 1994 Markus Wild
9 * Copyright (c) 1994 Lutz Vieweg
10 * All rights reserved.
11 *
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
14 * are met:
15 * 1. Redistributions of source code must retain the above copyright
16 * notice, this list of conditions and the following disclaimer.
17 * 2. Redistributions in binary form must reproduce the above copyright
18 * notice, this list of conditions and the following disclaimer in the
19 * documentation and/or other materials provided with the distribution.
20 * 3. All advertising materials mentioning features or use of this software
21 * must display the following acknowledgement:
22 * This product includes software developed by Lutz Vieweg.
23 * 4. The name of the author may not be used to endorse or promote products
24 * derived from this software without specific prior written permission
25 *
26 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
27 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
28 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
29 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
30 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
31 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
32 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
33 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
34 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
35 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36 */
37 #include "opt_amigacons.h"
38
39 #include <sys/cdefs.h>
40 __KERNEL_RCSID(0, "$NetBSD: grf_et.c,v 1.27 2009/03/18 17:06:42 cegger Exp $");
41
42 #include "grfet.h"
43 #if NGRFET > 0
44
45 /*
46 * Graphics routines for Tseng ET4000 (&W32) boards,
47 *
48 * This code offers low-level routines to access Tseng ET4000
49 * graphics-boards from within NetBSD for the Amiga.
50 * No warranties for any kind of function at all - this
51 * code may crash your hardware and scratch your harddisk. Use at your
52 * own risk. Freely distributable.
53 *
54 * Modified for Tseng ET4000 from
55 * Kari Mettinen's Cirrus driver by Tobias Abt
56 *
57 * Fixed Merlin in Z-III, fixed LACE and DBLSCAN, added Domino16M proto
58 * and AT&T ATT20c491 DAC, added memory-size detection by Klaus Burkert.
59 *
60 *
61 * TODO:
62 *
63 */
64
65 #include <sys/param.h>
66 #include <sys/systm.h>
67 #include <sys/errno.h>
68 #include <sys/ioctl.h>
69 #include <sys/device.h>
70 #include <sys/malloc.h>
71
72 #include <machine/cpu.h>
73 #include <dev/cons.h>
74 #ifdef TSENGCONSOLE
75 #include <amiga/dev/itevar.h>
76 #endif
77 #include <amiga/amiga/device.h>
78 #include <amiga/dev/grfioctl.h>
79 #include <amiga/dev/grfvar.h>
80 #include <amiga/dev/grf_etreg.h>
81 #include <amiga/dev/zbusvar.h>
82
83 int et_mondefok(struct grfvideo_mode *gv);
84 void et_boardinit(struct grf_softc *gp);
85 static void et_CompFQ(u_int fq, u_char *num, u_char *denom);
86 int et_getvmode(struct grf_softc *gp, struct grfvideo_mode *vm);
87 int et_setvmode(struct grf_softc *gp, unsigned int mode);
88 int et_toggle(struct grf_softc *gp, unsigned short);
89 int et_getcmap(struct grf_softc *gfp, struct grf_colormap *cmap);
90 int et_putcmap(struct grf_softc *gfp, struct grf_colormap *cmap);
91 #ifndef TSENGCONSOLE
92 void et_off(struct grf_softc *gp);
93 #endif
94 void et_inittextmode(struct grf_softc *gp);
95 int et_ioctl(register struct grf_softc *gp, u_long cmd, void *data);
96 int et_getmousepos(struct grf_softc *gp, struct grf_position *data);
97 void et_writesprpos(volatile char *ba, short x, short y);
98 int et_setmousepos(struct grf_softc *gp, struct grf_position *data);
99 static int et_setspriteinfo(struct grf_softc *gp, struct grf_spriteinfo *data);
100 int et_getspriteinfo(struct grf_softc *gp, struct grf_spriteinfo *data);
101 static int et_getspritemax(struct grf_softc *gp, struct grf_position *data);
102 int et_setmonitor(struct grf_softc *gp, struct grfvideo_mode *gv);
103 int et_blank(struct grf_softc *gp, int *on);
104 static int et_getControllerType(struct grf_softc *gp);
105 static int et_getDACType(struct grf_softc *gp);
106
107 int grfetmatch(struct device *, struct cfdata *, void *);
108 void grfetattach(struct device *, struct device *, void *);
109 int grfetprint(void *, const char *);
110 void et_memset(volatile unsigned char *d, unsigned char c, int l);
111
112 /*
113 * Graphics display definitions.
114 * These are filled by 'grfconfig' using GRFIOCSETMON.
115 */
116 #define monitor_def_max 24
117 static struct grfvideo_mode monitor_def[24] = {
118 {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0},
119 {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0},
120 {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}
121 };
122 static struct grfvideo_mode *monitor_current = &monitor_def[0];
123
124 /* Console display definition.
125 * Default hardcoded text mode. This grf_et is set up to
126 * use one text mode only, and this is it. You may use
127 * grfconfig to change the mode after boot.
128 */
129 /* Console font */
130 #ifdef KFONT_8X11
131 #define TSENGFONT kernel_font_8x11
132 #define TSENGFONTY 11
133 #else
134 #define TSENGFONT kernel_font_8x8
135 #define TSENGFONTY 8
136 #endif
137 extern unsigned char TSENGFONT[];
138
139 struct grfettext_mode etconsole_mode = {
140 {255, "", 25000000, 640, 480, 4, 640/8, 680/8, 768/8, 800/8,
141 481, 491, 493, 525, 0},
142 8, TSENGFONTY, 640 / 8, 480 / TSENGFONTY, TSENGFONT, 32, 255
143 };
144
145 /* Console colors */
146 unsigned char etconscolors[3][3] = { /* background, foreground, hilite */
147 {0, 0x40, 0x50}, {152, 152, 152}, {255, 255, 255}
148 };
149
150 int ettype = 0; /* oMniBus, Domino or Merlin */
151 int etctype = 0; /* ET4000 or ETW32 */
152 int etdtype = 0; /* Type of DAC (see grf_etregs.h) */
153
154 char etcmap_shift = 0; /* 6 or 8 bit cmap entries */
155 unsigned char pass_toggle; /* passthru status tracker */
156
157 unsigned char Merlin_switch = 0;
158
159 /*
160 * Because all Tseng-boards have 2 configdev entries, one for
161 * framebuffer mem and the other for regs, we have to hold onto
162 * the pointers globally until we match on both. This and 'ettype'
163 * are the primary obsticles to multiple board support, but if you
164 * have multiple boards you have bigger problems than grf_et.
165 */
166 static void *et_fbaddr = 0; /* framebuffer */
167 static void *et_regaddr = 0; /* registers */
168 static int et_fbsize; /* framebuffer size */
169
170 /* current sprite info, if you add support for multiple boards
171 * make this an array or something
172 */
173 struct grf_spriteinfo et_cursprite;
174
175 /* sprite bitmaps in kernel stack, you'll need to arrayize these too if
176 * you add multiple board support
177 */
178 static unsigned char et_imageptr[8 * 64], et_maskptr[8 * 64];
179 static unsigned char et_sprred[2], et_sprgreen[2], et_sprblue[2];
180
181 /* standard driver stuff */
182 CFATTACH_DECL(grfet, sizeof(struct grf_softc),
183 grfetmatch, grfetattach, NULL, NULL);
184
185 static struct cfdata *cfdata;
186
187 int
188 grfetmatch(struct device *pdp, struct cfdata *cfp, void *auxp)
189 {
190 struct zbus_args *zap;
191 static int regprod, regprod2 = 0, fbprod;
192
193 zap = auxp;
194
195 #ifndef TSENGCONSOLE
196 if (amiga_realconfig == 0)
197 return (0);
198 #endif
199
200 /* Grab the first board we encounter as the preferred one. This will
201 * allow one board to work in a multiple Tseng board system, but not
202 * multiple boards at the same time. */
203 if (ettype == 0) {
204 switch (zap->manid) {
205 case OMNIBUS:
206 if (zap->prodid != 0)
207 return (0);
208 regprod = 0;
209 fbprod = 0;
210 break;
211 case DOMINO:
212 /* 2167/3 is Domino16M proto (crest) */
213 if (zap->prodid != 3 && zap->prodid != 2 && zap->prodid != 1)
214 return (0);
215 regprod = 2;
216 regprod2 = 3;
217 fbprod = 1;
218 break;
219 case MERLIN:
220 if (zap->prodid != 3 && zap->prodid != 4)
221 return (0);
222 regprod = 4;
223 fbprod = 3;
224 break;
225 default:
226 return (0);
227 }
228 ettype = zap->manid;
229 } else {
230 if (ettype != zap->manid) {
231 return (0);
232 }
233 }
234
235 /* Configure either registers or framebuffer in any order */
236 /* as said before, oMniBus does not support ProdID */
237 if (ettype == OMNIBUS) {
238 if (zap->size == 64 * 1024) {
239 /* register area */
240 et_regaddr = zap->va;
241 } else {
242 /* memory area */
243 et_fbaddr = zap->va;
244 et_fbsize = zap->size;
245 }
246 } else {
247 if (zap->prodid == regprod || zap->prodid == regprod2) {
248 et_regaddr = zap->va;
249 } else {
250 if (zap->prodid == fbprod) {
251 et_fbaddr = zap->va;
252 et_fbsize = zap->size;
253 } else {
254 return (0);
255 }
256 }
257 }
258
259 #ifdef TSENGCONSOLE
260 if (amiga_realconfig == 0) {
261 cfdata = cfp;
262 }
263 #endif
264
265 return (1);
266 }
267
268
269 void
270 grfetattach(struct device *pdp, struct device *dp, void *auxp)
271 {
272 static struct grf_softc congrf;
273 struct zbus_args *zap;
274 struct grf_softc *gp;
275 static char attachflag = 0;
276
277 zap = auxp;
278
279 printf("\n");
280
281 /* make sure both halves have matched */
282 if (!et_regaddr || !et_fbaddr)
283 return;
284
285 /* do all that messy console/grf stuff */
286 if (dp == NULL)
287 gp = &congrf;
288 else
289 gp = (struct grf_softc *) dp;
290
291 if (dp != NULL && congrf.g_regkva != 0) {
292 /*
293 * inited earlier, just copy (not device struct)
294 */
295 memcpy(&gp->g_display, &congrf.g_display,
296 (char *) &gp[1] - (char *) &gp->g_display);
297 } else {
298 gp->g_regkva = (volatile void *) et_regaddr;
299 gp->g_fbkva = (volatile void *) et_fbaddr;
300
301 gp->g_unit = GRF_ET4000_UNIT;
302 gp->g_mode = et_mode;
303 gp->g_conpri = grfet_cnprobe();
304 gp->g_flags = GF_ALIVE;
305
306 /* wakeup the board */
307 et_boardinit(gp);
308
309 #ifdef TSENGCONSOLE
310 grfet_iteinit(gp);
311 (void) et_load_mon(gp, &etconsole_mode);
312 #endif
313 }
314
315 /*
316 * attach grf (once)
317 */
318 if (amiga_config_found(cfdata, &gp->g_device, gp, grfetprint)) {
319 attachflag = 1;
320 printf("grfet: %dMB ", et_fbsize / 0x100000);
321 switch (ettype) {
322 case OMNIBUS:
323 printf("oMniBus");
324 break;
325 case DOMINO:
326 printf("Domino");
327 break;
328 case MERLIN:
329 printf("Merlin");
330 break;
331 }
332 printf(" with ");
333 switch (etctype) {
334 case ET4000:
335 printf("Tseng ET4000");
336 break;
337 case ETW32:
338 printf("Tseng ETW32");
339 break;
340 }
341 printf(" and ");
342 switch (etdtype) {
343 case SIERRA11483:
344 printf("Sierra SC11483 DAC");
345 break;
346 case SIERRA15025:
347 printf("Sierra SC15025 DAC");
348 break;
349 case MUSICDAC:
350 printf("MUSIC DAC");
351 break;
352 case MERLINDAC:
353 printf("BrookTree Bt482 DAC");
354 break;
355 case ATT20C491:
356 printf("AT&T ATT20c491 DAC");
357 break;
358 }
359 printf(" being used\n");
360 } else {
361 if (!attachflag)
362 printf("grfet unattached!!\n");
363 }
364 }
365
366
367 int
368 grfetprint(void *auxp, const char *pnp)
369 {
370 if (pnp)
371 aprint_normal("ite at %s: ", pnp);
372 return (UNCONF);
373 }
374
375
376 void
377 et_boardinit(struct grf_softc *gp)
378 {
379 volatile unsigned char *ba = gp->g_regkva;
380 int x;
381
382 /* wakeup board and flip passthru OFF */
383
384 RegWakeup(ba);
385 RegOnpass(ba);
386
387 if (ettype == MERLIN) {
388 /* Merlin needs some special initialisations */
389 vgaw(ba, MERLIN_SWITCH_REG, 0);
390 delay(20000);
391 vgaw(ba, MERLIN_SWITCH_REG, 8);
392 delay(20000);
393 vgaw(ba, MERLIN_SWITCH_REG, 0);
394 delay(20000);
395 vgaw(ba, MERLIN_VDAC_DATA, 1);
396
397 vgaw(ba, MERLIN_VDAC_INDEX, 0x00);
398 vgaw(ba, MERLIN_VDAC_SPRITE, 0xff);
399 vgaw(ba, MERLIN_VDAC_INDEX, 0x01);
400 vgaw(ba, MERLIN_VDAC_SPRITE, 0x0f);
401 vgaw(ba, MERLIN_VDAC_INDEX, 0x02);
402 vgaw(ba, MERLIN_VDAC_SPRITE, 0x42);
403 vgaw(ba, MERLIN_VDAC_INDEX, 0x03);
404 vgaw(ba, MERLIN_VDAC_SPRITE, 0x00);
405
406 vgaw(ba, MERLIN_VDAC_DATA, 0);
407 }
408
409
410 /* setup initial unchanging parameters */
411
412 vgaw(ba, GREG_HERCULESCOMPAT + ((ettype == DOMINO) ? 0x0fff : 0), 0x03);
413 vgaw(ba, GREG_DISPMODECONTROL, 0xa0);
414 vgaw(ba, GREG_MISC_OUTPUT_W, 0x63);
415
416 if (ettype == DOMINO)
417 {
418 vgaw(ba, CRT_ADDRESS, CRT_ID_VIDEO_CONFIG1);
419 vgaw(ba, CRT_ADDRESS_W + 0x0fff,
420 0xc0 | vgar(ba, CRT_ADDRESS_R + 0x0fff));
421 }
422
423 WSeq(ba, SEQ_ID_RESET, 0x03);
424 WSeq(ba, SEQ_ID_CLOCKING_MODE, 0x21); /* 8 dot, Display off */
425 WSeq(ba, SEQ_ID_MAP_MASK, 0x0f);
426 WSeq(ba, SEQ_ID_CHAR_MAP_SELECT, 0x00);
427 WSeq(ba, SEQ_ID_MEMORY_MODE, 0x0e);
428 WSeq(ba, SEQ_ID_STATE_CONTROL, 0x00);
429 WSeq(ba, SEQ_ID_AUXILIARY_MODE, 0xf4);
430
431 WCrt(ba, CRT_ID_PRESET_ROW_SCAN, 0x00);
432 WCrt(ba, CRT_ID_CURSOR_START, 0x00);
433 WCrt(ba, CRT_ID_CURSOR_END, 0x08);
434 WCrt(ba, CRT_ID_START_ADDR_HIGH, 0x00);
435 WCrt(ba, CRT_ID_START_ADDR_LOW, 0x00);
436 WCrt(ba, CRT_ID_CURSOR_LOC_HIGH, 0x00);
437 WCrt(ba, CRT_ID_CURSOR_LOC_LOW, 0x00);
438
439 WCrt(ba, CRT_ID_UNDERLINE_LOC, 0x67);
440 WCrt(ba, CRT_ID_MODE_CONTROL, 0xc3);
441 WCrt(ba, CRT_ID_LINE_COMPARE, 0xff);
442
443 /* ET4000 special */
444 WCrt(ba, CRT_ID_RASCAS_CONFIG, 0x28);
445 WCrt(ba, CRT_ID_EXT_START, 0x00);
446 WCrt(ba, CRT_ID_6845_COMPAT, 0x08);
447
448 /* ET4000/W32 special (currently only for Merlin (crest) */
449 if (ettype == MERLIN) {
450 WCrt(ba, CRT_ID_SEGMENT_COMP, 0x1c);
451 WCrt(ba, CRT_ID_GENERAL_PURPOSE, 0x00);
452 WCrt(ba, CRT_ID_VIDEO_CONFIG1, 0x93);
453 }
454 else {
455 WCrt(ba, CRT_ID_VIDEO_CONFIG1, 0xd3);
456 }
457
458 WCrt(ba, CRT_ID_VIDEO_CONFIG2, 0x0f);
459 WCrt(ba, CRT_ID_HOR_OVERFLOW, 0x00);
460
461 vgaw(ba, GREG_SEGMENTSELECT, 0x00);
462
463 WGfx(ba, GCT_ID_SET_RESET, 0x00);
464 WGfx(ba, GCT_ID_ENABLE_SET_RESET, 0x00);
465 WGfx(ba, GCT_ID_COLOR_COMPARE, 0x00);
466 WGfx(ba, GCT_ID_DATA_ROTATE, 0x00);
467 WGfx(ba, GCT_ID_READ_MAP_SELECT, 0x00);
468 WGfx(ba, GCT_ID_GRAPHICS_MODE, 0x40);
469 WGfx(ba, GCT_ID_MISC, 0x01);
470 WGfx(ba, GCT_ID_COLOR_XCARE, 0x0f);
471 WGfx(ba, GCT_ID_BITMASK, 0xff);
472
473 for (x = 0; x < 0x10; x++)
474 WAttr(ba, x, x);
475 WAttr(ba, ACT_ID_ATTR_MODE_CNTL, 0x01);
476 WAttr(ba, ACT_ID_OVERSCAN_COLOR, 0x00);
477 WAttr(ba, ACT_ID_COLOR_PLANE_ENA, 0x0f);
478 WAttr(ba, ACT_ID_HOR_PEL_PANNING, 0x00);
479 WAttr(ba, ACT_ID_COLOR_SELECT, 0x00);
480 WAttr(ba, ACT_ID_MISCELLANEOUS, 0x00);
481
482 vgaw(ba, VDAC_MASK, 0xff);
483 delay(200000);
484 vgaw(ba, GREG_MISC_OUTPUT_W, 0xe3);
485
486 /* colors initially set to greyscale */
487 switch(ettype) {
488 case MERLIN:
489 vgaw(ba, MERLIN_VDAC_INDEX, 0);
490 for (x = 255; x >= 0; x--) {
491 vgaw(ba, MERLIN_VDAC_COLORS, x);
492 vgaw(ba, MERLIN_VDAC_COLORS, x);
493 vgaw(ba, MERLIN_VDAC_COLORS, x);
494 }
495 break;
496 default:
497 vgaw(ba, VDAC_ADDRESS_W, 0);
498 for (x = 255; x >= 0; x--) {
499 vgaw(ba, VDAC_DATA + ((ettype == DOMINO) ? 0x0fff : 0), x);
500 vgaw(ba, VDAC_DATA + ((ettype == DOMINO) ? 0x0fff : 0), x);
501 vgaw(ba, VDAC_DATA + ((ettype == DOMINO) ? 0x0fff : 0), x);
502 }
503 break;
504 }
505 /* set sprite bitmap pointers */
506 /* should work like that */
507 et_cursprite.image = et_imageptr;
508 et_cursprite.mask = et_maskptr;
509 et_cursprite.cmap.red = et_sprred;
510 et_cursprite.cmap.green = et_sprgreen;
511 et_cursprite.cmap.blue = et_sprblue;
512
513 /* card specific initialisations */
514 switch(ettype) {
515 case OMNIBUS:
516 etctype = et_getControllerType(gp);
517 etdtype = et_getDACType(gp);
518 break;
519 case MERLIN:
520 vgaw(ba, GREG_SEGMENTSELECT2, 0x00);
521 if (((vgar(ba, GREG_FEATURE_CONTROL_R) & 12) |
522 (vgar(ba, GREG_STATUS0_R) & 0x60)) == 0x24) {
523 WCrt(ba, CRT_ID_VIDEO_CONFIG2, 0x07); /* 1Mx4 RAM */
524 et_fbsize = 0x400000; /* 4 MB */
525 }
526 else {
527 /* check for 1MB or 2MB board (crest) */
528 /* has there a 1MB Merlin ever been sold ??? */
529 volatile unsigned long *et_fbtestaddr;
530 et_fbtestaddr = (volatile unsigned long *)gp->g_fbkva;
531 *et_fbtestaddr = 0x0;
532 vgaw(ba, GREG_SEGMENTSELECT2, 0x11); /* 1MB offset */
533 *et_fbtestaddr = 0x12345678;
534 vgaw(ba, GREG_SEGMENTSELECT2, 0x00);
535 if (*et_fbtestaddr == 0x0)
536 et_fbsize = 0x200000; /* 2 MB */
537 else
538 et_fbsize = 0x100000; /* 1 MB */
539 }
540 /* ZorroII can map 2 MB max ... */
541 if (!iszthreepa(kvtop(__UNVOLATILE(gp->g_fbkva))) &&
542 et_fbsize == 0x400000)
543 et_fbsize = 0x200000;
544 etctype = ETW32;
545 etdtype = MERLINDAC;
546 break;
547 case DOMINO:
548 etctype = ET4000;
549 etdtype = et_getDACType(gp);
550 break;
551 }
552 }
553
554
555 int
556 et_getvmode(struct grf_softc *gp, struct grfvideo_mode *vm)
557 {
558 struct grfvideo_mode *gv;
559
560 #ifdef TSENGCONSOLE
561 /* Handle grabbing console mode */
562 if (vm->mode_num == 255) {
563 memcpy(vm, &etconsole_mode, sizeof(struct grfvideo_mode));
564 /* XXX so grfconfig can tell us the correct text dimensions. */
565 vm->depth = etconsole_mode.fy;
566 } else
567 #endif
568 {
569 if (vm->mode_num == 0)
570 vm->mode_num = (monitor_current - monitor_def) + 1;
571 if (vm->mode_num < 1 || vm->mode_num > monitor_def_max)
572 return (EINVAL);
573 gv = monitor_def + (vm->mode_num - 1);
574 if (gv->mode_num == 0)
575 return (EINVAL);
576
577 memcpy(vm, gv, sizeof(struct grfvideo_mode));
578 }
579
580 /* adjust internal values to pixel values */
581
582 vm->hblank_start *= 8;
583 vm->hsync_start *= 8;
584 vm->hsync_stop *= 8;
585 vm->htotal *= 8;
586
587 return (0);
588 }
589
590
591 int
592 et_setvmode(struct grf_softc *gp, unsigned mode)
593 {
594 if (!mode || (mode > monitor_def_max) ||
595 monitor_def[mode - 1].mode_num == 0)
596 return (EINVAL);
597
598 monitor_current = monitor_def + (mode - 1);
599
600 return (0);
601 }
602
603
604 #ifndef TSENGCONSOLE
605 void
606 et_off(struct grf_softc *gp)
607 {
608 char *ba = gp->g_regkva;
609
610 RegOnpass(ba);
611 WSeq(ba, SEQ_ID_CLOCKING_MODE, 0x21);
612 }
613 #endif
614
615
616 int
617 et_blank(struct grf_softc *gp, int *on)
618 {
619 WSeq(gp->g_regkva, SEQ_ID_CLOCKING_MODE, *on > 0 ? 0x01 : 0x21);
620 return(0);
621 }
622
623
624 /*
625 * Change the mode of the display.
626 * Return a UNIX error number or 0 for success.
627 */
628 int
629 et_mode(register struct grf_softc *gp, u_long cmd, void *arg, u_long a2,
630 int a3)
631 {
632 int error;
633
634 switch (cmd) {
635 case GM_GRFON:
636 error = et_load_mon(gp,
637 (struct grfettext_mode *) monitor_current) ? 0 : EINVAL;
638 return (error);
639
640 case GM_GRFOFF:
641 #ifndef TSENGCONSOLE
642 et_off(gp);
643 #else
644 et_load_mon(gp, &etconsole_mode);
645 #endif
646 return (0);
647
648 case GM_GRFCONFIG:
649 return (0);
650
651 case GM_GRFGETVMODE:
652 return (et_getvmode(gp, (struct grfvideo_mode *) arg));
653
654 case GM_GRFSETVMODE:
655 error = et_setvmode(gp, *(unsigned *) arg);
656 if (!error && (gp->g_flags & GF_GRFON))
657 et_load_mon(gp,
658 (struct grfettext_mode *) monitor_current);
659 return (error);
660
661 case GM_GRFGETNUMVM:
662 *(int *) arg = monitor_def_max;
663 return (0);
664
665 case GM_GRFIOCTL:
666 return (et_ioctl(gp, a2, arg));
667
668 default:
669 break;
670 }
671
672 return (EPASSTHROUGH);
673 }
674
675
676 int
677 et_ioctl(register struct grf_softc *gp, u_long cmd, void *data)
678 {
679 switch (cmd) {
680 case GRFIOCGSPRITEPOS:
681 return (et_getmousepos(gp, (struct grf_position *) data));
682
683 case GRFIOCSSPRITEPOS:
684 return (et_setmousepos(gp, (struct grf_position *) data));
685
686 case GRFIOCSSPRITEINF:
687 return (et_setspriteinfo(gp, (struct grf_spriteinfo *) data));
688
689 case GRFIOCGSPRITEINF:
690 return (et_getspriteinfo(gp, (struct grf_spriteinfo *) data));
691
692 case GRFIOCGSPRITEMAX:
693 return (et_getspritemax(gp, (struct grf_position *) data));
694
695 case GRFIOCGETCMAP:
696 return (et_getcmap(gp, (struct grf_colormap *) data));
697
698 case GRFIOCPUTCMAP:
699 return (et_putcmap(gp, (struct grf_colormap *) data));
700
701 case GRFIOCBITBLT:
702 break;
703
704 case GRFTOGGLE:
705 return (et_toggle(gp, 0));
706
707 case GRFIOCSETMON:
708 return (et_setmonitor(gp, (struct grfvideo_mode *) data));
709
710 case GRFIOCBLANK:
711 return (et_blank(gp, (int *)data));
712 }
713 return (EPASSTHROUGH);
714 }
715
716
717 int
718 et_getmousepos(struct grf_softc *gp, struct grf_position *data)
719 {
720 data->x = et_cursprite.pos.x;
721 data->y = et_cursprite.pos.y;
722
723 return (0);
724 }
725
726
727 void
728 et_writesprpos(volatile char *ba, short x, short y)
729 {
730 }
731
732
733 int
734 et_setmousepos(struct grf_softc *gp, struct grf_position *data)
735 {
736 volatile char *ba = gp->g_regkva;
737 short rx, ry, prx, pry;
738
739 /* no movement */
740 if (et_cursprite.pos.x == data->x && et_cursprite.pos.y == data->y)
741 return (0);
742
743 /* current and previous real coordinates */
744 rx = data->x - et_cursprite.hot.x;
745 ry = data->y - et_cursprite.hot.y;
746 prx = et_cursprite.pos.x - et_cursprite.hot.x;
747 pry = et_cursprite.pos.y - et_cursprite.hot.y;
748
749 /* if we are/were on an edge, create (un)shifted bitmap --
750 * ripped out optimization (not extremely worthwhile,
751 * and kind of buggy anyhow).
752 */
753
754 /* do movement, save position */
755 et_writesprpos(ba, rx < 0 ? 0 : rx, ry < 0 ? 0 : ry);
756 et_cursprite.pos.x = data->x;
757 et_cursprite.pos.y = data->y;
758
759 return (0);
760 }
761
762
763 int
764 et_getspriteinfo(struct grf_softc *gp, struct grf_spriteinfo *data)
765 {
766
767 return(EINVAL);
768 }
769
770
771 static int
772 et_setspriteinfo(struct grf_softc *gp, struct grf_spriteinfo *data)
773 {
774
775 return(EINVAL);
776 }
777
778
779 static int
780 et_getspritemax(struct grf_softc *gp, struct grf_position *data)
781 {
782
783 return(EINVAL);
784 }
785
786
787 int
788 et_setmonitor(struct grf_softc *gp, struct grfvideo_mode *gv)
789 {
790 struct grfvideo_mode *md;
791
792 if (!et_mondefok(gv))
793 return(EINVAL);
794
795 #ifdef TSENGCONSOLE
796 /* handle interactive setting of console mode */
797 if (gv->mode_num == 255) {
798 memcpy(&etconsole_mode.gv, gv, sizeof(struct grfvideo_mode));
799 etconsole_mode.gv.hblank_start /= 8;
800 etconsole_mode.gv.hsync_start /= 8;
801 etconsole_mode.gv.hsync_stop /= 8;
802 etconsole_mode.gv.htotal /= 8;
803 etconsole_mode.rows = gv->disp_height / etconsole_mode.fy;
804 etconsole_mode.cols = gv->disp_width / etconsole_mode.fx;
805 if (!(gp->g_flags & GF_GRFON))
806 et_load_mon(gp, &etconsole_mode);
807 ite_reinit(gp->g_itedev);
808 return (0);
809 }
810 #endif
811
812 md = monitor_def + (gv->mode_num - 1);
813 memcpy(md, gv, sizeof(struct grfvideo_mode));
814
815 /* adjust pixel oriented values to internal rep. */
816
817 md->hblank_start /= 8;
818 md->hsync_start /= 8;
819 md->hsync_stop /= 8;
820 md->htotal /= 8;
821
822 return (0);
823 }
824
825
826 int
827 et_getcmap(struct grf_softc *gfp, struct grf_colormap *cmap)
828 {
829 volatile unsigned char *ba;
830 u_char red[256], green[256], blue[256], *rp, *gp, *bp;
831 short x;
832 int error;
833
834 if (cmap->count == 0 || cmap->index >= 256)
835 return 0;
836
837 if (cmap->count > 256 - cmap->index)
838 cmap->count = 256 - cmap->index;
839
840 ba = gfp->g_regkva;
841 /* first read colors out of the chip, then copyout to userspace */
842 x = cmap->count - 1;
843
844 rp = red + cmap->index;
845 gp = green + cmap->index;
846 bp = blue + cmap->index;
847
848 switch(ettype) {
849 case MERLIN:
850 vgaw(ba, MERLIN_VDAC_INDEX, cmap->index);
851 do {
852 *rp++ = vgar(ba, MERLIN_VDAC_COLORS);
853 *gp++ = vgar(ba, MERLIN_VDAC_COLORS);
854 *bp++ = vgar(ba, MERLIN_VDAC_COLORS);
855 } while (x-- > 0);
856 break;
857 default:
858 vgaw(ba, VDAC_ADDRESS_R+((ettype==DOMINO)?0x0fff:0), cmap->index);
859 do {
860 *rp++ = vgar(ba, VDAC_DATA+((ettype==DOMINO)?0x0fff:0)) << etcmap_shift;
861 *gp++ = vgar(ba, VDAC_DATA+((ettype==DOMINO)?0x0fff:0)) << etcmap_shift;
862 *bp++ = vgar(ba, VDAC_DATA+((ettype==DOMINO)?0x0fff:0)) << etcmap_shift;
863 } while (x-- > 0);
864 break;
865 }
866
867 error = copyout(red + cmap->index, cmap->red, cmap->count);
868 if (!error)
869 error = copyout(green + cmap->index, cmap->green, cmap->count);
870 if (!error)
871 error = copyout(blue + cmap->index, cmap->blue, cmap->count);
872
873 return (error);
874 }
875
876
877 int
878 et_putcmap(struct grf_softc *gfp, struct grf_colormap *cmap)
879 {
880 volatile unsigned char *ba;
881 u_char red[256], green[256], blue[256], *rp, *gp, *bp;
882 short x;
883 int error;
884
885 if (cmap->count == 0 || cmap->index >= 256)
886 return (0);
887
888 if (cmap->count > 256 - cmap->index)
889 cmap->count = 256 - cmap->index;
890
891 /* first copy the colors into kernelspace */
892 if ((error = copyin(cmap->red, red + cmap->index, cmap->count)))
893 return (error);
894
895 if ((error = copyin(cmap->green, green + cmap->index, cmap->count)))
896 return (error);
897
898 if ((error = copyin(cmap->blue, blue + cmap->index, cmap->count)))
899 return (error);
900
901 ba = gfp->g_regkva;
902 x = cmap->count - 1;
903
904 rp = red + cmap->index;
905 gp = green + cmap->index;
906 bp = blue + cmap->index;
907
908 switch(ettype){
909 case MERLIN:
910 vgaw(ba, MERLIN_VDAC_INDEX, cmap->index);
911 do {
912 vgaw(ba, MERLIN_VDAC_COLORS, *rp++);
913 vgaw(ba, MERLIN_VDAC_COLORS, *gp++);
914 vgaw(ba, MERLIN_VDAC_COLORS, *bp++);
915 } while (x-- > 0);
916 break;
917 default:
918 vgaw(ba, VDAC_ADDRESS_W, cmap->index);
919 do {
920 vgaw(ba, VDAC_DATA + ((ettype == DOMINO) ? 0x0fff : 0),
921 *rp++ >> etcmap_shift);
922 vgaw(ba, VDAC_DATA + ((ettype == DOMINO) ? 0x0fff : 0),
923 *gp++ >> etcmap_shift);
924 vgaw(ba, VDAC_DATA + ((ettype == DOMINO) ? 0x0fff : 0),
925 *bp++ >> etcmap_shift);
926 } while (x-- > 0);
927 break;
928 }
929
930 return (0);
931 }
932
933
934 int
935 et_toggle(struct grf_softc *gp, unsigned short wopp)
936 /* (variable wopp) don't need that one yet, ill */
937 {
938 volatile unsigned char *ba;
939
940 ba = gp->g_regkva;
941
942 if (pass_toggle) {
943 RegOffpass(ba);
944 } else {
945 RegOnpass(ba);
946 }
947 return (0);
948 }
949
950
951 #define ET_NUMCLOCKS 32
952
953 static u_char et_clocks[ET_NUMCLOCKS] = {
954 0, 1, 6, 2, 3, 7, 4, 5,
955 0, 1, 6, 2, 3, 7, 4, 5,
956 0, 1, 6, 2, 3, 7, 4, 5,
957 0, 1, 6, 2, 3, 7, 4, 5
958 };
959
960 static u_char et_clockdividers[ET_NUMCLOCKS] = {
961 3, 3, 3, 3, 3, 3, 3, 3,
962 2, 2, 2, 2, 2, 2, 2, 2,
963 1, 1, 1, 1, 1, 1, 1, 1,
964 0, 0, 0, 0, 0, 0, 0, 0
965 };
966
967 static u_int et_clockfreqs[ET_NUMCLOCKS] = {
968 6293750, 7080500, 7875000, 8125000,
969 9000000, 9375000, 10000000, 11225000,
970 12587500, 14161000, 15750000, 16250000,
971 18000000, 18750000, 20000000, 22450000,
972 25175000, 28322000, 31500000, 32500000,
973 36000000, 37500000, 40000000, 44900000,
974 50350000, 56644000, 63000000, 65000000,
975 72000000, 75000000, 80000000, 89800000
976 };
977
978
979 static void
980 et_CompFQ(u_int fq, u_char *num, u_char *denom)
981 {
982 int i;
983
984 for (i=0; i < ET_NUMCLOCKS;) {
985 if (fq <= et_clockfreqs[i++]) {
986 break;
987 }
988 }
989
990 *num = et_clocks[--i];
991 *denom = et_clockdividers[i];
992
993 return;
994 }
995
996
997 int
998 et_mondefok(struct grfvideo_mode *gv)
999 {
1000 unsigned long maxpix;
1001
1002 if (gv->mode_num < 1 || gv->mode_num > monitor_def_max)
1003 if (gv->mode_num != 255 || gv->depth != 4)
1004 return(0);
1005
1006 switch (gv->depth) {
1007 case 4:
1008 if (gv->mode_num != 255)
1009 return(0);
1010 case 1:
1011 case 8:
1012 maxpix = 85000000;
1013 break;
1014 case 15:
1015 case 16:
1016 maxpix = 45000000;
1017 break;
1018 case 24:
1019 maxpix = 28000000;
1020 break;
1021 case 32:
1022 maxpix = 21000000;
1023 break;
1024 default:
1025 printf("grfet: Illegal depth in mode %d\n",
1026 (int) gv->mode_num);
1027 return (0);
1028 }
1029
1030 if (gv->pixel_clock > maxpix) {
1031 printf("grfet: Pixelclock too high in mode %d\n",
1032 (int) gv->mode_num);
1033 return (0);
1034 }
1035
1036 if (gv->disp_flags & GRF_FLAGS_SYNC_ON_GREEN) {
1037 printf("grfet: sync-on-green is not supported\n");
1038 return (0);
1039 }
1040
1041 return (1);
1042 }
1043
1044
1045 int
1046 et_load_mon(struct grf_softc *gp, struct grfettext_mode *md)
1047 {
1048 struct grfvideo_mode *gv;
1049 struct grfinfo *gi;
1050 volatile unsigned char *ba;
1051 unsigned char num0, denom0;
1052 unsigned short HT, HDE, HBS, HBE, HSS, HSE, VDE, VBS, VBE, VSS,
1053 VSE, VT;
1054 unsigned char hvsync_pulse, seq;
1055 char TEXT;
1056 int hmul;
1057
1058 /* identity */
1059 gv = &md->gv;
1060 TEXT = (gv->depth == 4);
1061
1062 if (!et_mondefok(gv)) {
1063 printf("grfet: Monitor definition not ok\n");
1064 return (0);
1065 }
1066
1067 ba = gp->g_regkva;
1068
1069 /* provide all needed information in grf device-independent locations */
1070 gp->g_data = (void *) gv;
1071 gi = &gp->g_display;
1072 gi->gd_regaddr = ztwopa(__UNVOLATILE(ba));
1073 gi->gd_regsize = 64 * 1024;
1074 gi->gd_fbaddr = (void *) kvtop(__UNVOLATILE(gp->g_fbkva));
1075 gi->gd_fbsize = et_fbsize;
1076 gi->gd_colors = 1 << gv->depth;
1077 gi->gd_planes = gv->depth;
1078 gi->gd_fbwidth = gv->disp_width;
1079 gi->gd_fbheight = gv->disp_height;
1080 gi->gd_fbx = 0;
1081 gi->gd_fby = 0;
1082 if (TEXT) {
1083 gi->gd_dwidth = md->fx * md->cols;
1084 gi->gd_dheight = md->fy * md->rows;
1085 } else {
1086 gi->gd_dwidth = gv->disp_width;
1087 gi->gd_dheight = gv->disp_height;
1088 }
1089 gi->gd_dx = 0;
1090 gi->gd_dy = 0;
1091
1092 /* get display mode parameters */
1093
1094 HBS = gv->hblank_start;
1095 HSS = gv->hsync_start;
1096 HSE = gv->hsync_stop;
1097 HBE = gv->htotal - 1;
1098 HT = gv->htotal;
1099 VBS = gv->vblank_start;
1100 VSS = gv->vsync_start;
1101 VSE = gv->vsync_stop;
1102 VBE = gv->vtotal - 1;
1103 VT = gv->vtotal;
1104
1105 if (TEXT)
1106 HDE = ((gv->disp_width + md->fx - 1) / md->fx) - 1;
1107 else
1108 HDE = (gv->disp_width + 3) / 8 - 1; /* HBS; */
1109 VDE = gv->disp_height - 1;
1110
1111 /* adjustments (crest) */
1112 switch (gv->depth) {
1113 case 15:
1114 case 16:
1115 hmul = 2;
1116 break;
1117 case 24:
1118 hmul = 3;
1119 break;
1120 case 32:
1121 hmul = 4;
1122 break;
1123 default:
1124 hmul = 1;
1125 break;
1126 }
1127
1128 HDE *= hmul;
1129 HBS *= hmul;
1130 HSS *= hmul;
1131 HSE *= hmul;
1132 HBE *= hmul;
1133 HT *= hmul;
1134
1135 if (gv->disp_flags & GRF_FLAGS_LACE) {
1136 VDE /= 2;
1137 VT = VT + 1;
1138 }
1139
1140 if (gv->disp_flags & GRF_FLAGS_DBLSCAN) {
1141 VDE *= 2;
1142 VBS *= 2;
1143 VSS *= 2;
1144 VSE *= 2;
1145 VBE *= 2;
1146 VT *= 2;
1147 }
1148
1149 WSeq(ba, SEQ_ID_MEMORY_MODE, (TEXT || (gv->depth == 1)) ? 0x06 : 0x0e);
1150
1151 WGfx(ba, GCT_ID_READ_MAP_SELECT, 0x00);
1152 WSeq(ba, SEQ_ID_MAP_MASK, (gv->depth == 1) ? 0x01 : 0xff);
1153 WSeq(ba, SEQ_ID_CHAR_MAP_SELECT, 0x00);
1154
1155 /* Set clock */
1156 et_CompFQ( gv->pixel_clock * hmul, &num0, &denom0);
1157
1158 /* Horizontal/Vertical Sync Pulse */
1159 hvsync_pulse = 0xe3;
1160 if (gv->disp_flags & GRF_FLAGS_PHSYNC)
1161 hvsync_pulse &= ~0x40;
1162 else
1163 hvsync_pulse |= 0x40;
1164 if (gv->disp_flags & GRF_FLAGS_PVSYNC)
1165 hvsync_pulse &= ~0x80;
1166 else
1167 hvsync_pulse |= 0x80;
1168
1169 vgaw(ba, GREG_MISC_OUTPUT_W, hvsync_pulse | ((num0 & 3) << 2));
1170 WCrt(ba, CRT_ID_6845_COMPAT, (num0 & 4) ? 0x0a : 0x08);
1171 seq = RSeq(ba, SEQ_ID_CLOCKING_MODE);
1172 switch(denom0) {
1173 case 0:
1174 WSeq(ba, SEQ_ID_AUXILIARY_MODE, 0xb4);
1175 WSeq(ba, SEQ_ID_CLOCKING_MODE, seq & 0xf7);
1176 break;
1177 case 1:
1178 WSeq(ba, SEQ_ID_AUXILIARY_MODE, 0xf4);
1179 WSeq(ba, SEQ_ID_CLOCKING_MODE, seq & 0xf7);
1180 break;
1181 case 2:
1182 WSeq(ba, SEQ_ID_AUXILIARY_MODE, 0xf5);
1183 WSeq(ba, SEQ_ID_CLOCKING_MODE, seq & 0xf7);
1184 break;
1185 case 3:
1186 WSeq(ba, SEQ_ID_AUXILIARY_MODE, 0xf5);
1187 WSeq(ba, SEQ_ID_CLOCKING_MODE, seq | 0x08);
1188 break;
1189 }
1190
1191 /* load display parameters into board */
1192 WCrt(ba, CRT_ID_HOR_TOTAL, HT);
1193 WCrt(ba, CRT_ID_HOR_DISP_ENA_END, ((HDE >= HBS) ? HBS - 1 : HDE));
1194 WCrt(ba, CRT_ID_START_HOR_BLANK, HBS);
1195 WCrt(ba, CRT_ID_END_HOR_BLANK, (HBE & 0x1f) | 0x80);
1196 WCrt(ba, CRT_ID_START_HOR_RETR, HSS);
1197 WCrt(ba, CRT_ID_END_HOR_RETR,
1198 (HSE & 0x1f) |
1199 ((HBE & 0x20) ? 0x80 : 0x00));
1200 WCrt(ba, CRT_ID_VER_TOTAL, VT);
1201 WCrt(ba, CRT_ID_OVERFLOW,
1202 0x10 |
1203 ((VT & 0x100) ? 0x01 : 0x00) |
1204 ((VDE & 0x100) ? 0x02 : 0x00) |
1205 ((VSS & 0x100) ? 0x04 : 0x00) |
1206 ((VBS & 0x100) ? 0x08 : 0x00) |
1207 ((VT & 0x200) ? 0x20 : 0x00) |
1208 ((VDE & 0x200) ? 0x40 : 0x00) |
1209 ((VSS & 0x200) ? 0x80 : 0x00));
1210
1211 WCrt(ba, CRT_ID_MAX_ROW_ADDRESS,
1212 0x40 | /* splitscreen not visible */
1213 ((gv->disp_flags & GRF_FLAGS_DBLSCAN) ? 0x80 : 0x00) |
1214 ((VBS & 0x200) ? 0x20 : 0x00) |
1215 (TEXT ? ((md->fy - 1) & 0x1f) : 0x00));
1216
1217 WCrt(ba, CRT_ID_MODE_CONTROL,
1218 ((TEXT || (gv->depth == 1)) ? 0xc3 : 0xab));
1219
1220 /* text cursor */
1221 if (TEXT) {
1222 #if ET_ULCURSOR
1223 WCrt(ba, CRT_ID_CURSOR_START, (md->fy & 0x1f) - 2);
1224 WCrt(ba, CRT_ID_CURSOR_END, (md->fy & 0x1f) - 1);
1225 #else
1226 WCrt(ba, CRT_ID_CURSOR_START, 0x00);
1227 WCrt(ba, CRT_ID_CURSOR_END, md->fy & 0x1f);
1228 #endif
1229 WCrt(ba, CRT_ID_CURSOR_LOC_HIGH, 0x00);
1230 WCrt(ba, CRT_ID_CURSOR_LOC_LOW, 0x00);
1231 }
1232
1233 WCrt(ba, CRT_ID_UNDERLINE_LOC, ((md->fy - 1) & 0x1f)
1234 | ((TEXT || (gv->depth == 1)) ? 0x00 : 0x60));
1235
1236 WCrt(ba, CRT_ID_START_ADDR_HIGH, 0x00);
1237 WCrt(ba, CRT_ID_START_ADDR_LOW, 0x00);
1238
1239 WCrt(ba, CRT_ID_START_VER_RETR, VSS);
1240 WCrt(ba, CRT_ID_END_VER_RETR, (VSE & 0x0f) | 0x30);
1241 WCrt(ba, CRT_ID_VER_DISP_ENA_END, VDE);
1242 WCrt(ba, CRT_ID_START_VER_BLANK, VBS);
1243 WCrt(ba, CRT_ID_END_VER_BLANK, VBE);
1244
1245 WCrt(ba, CRT_ID_LINE_COMPARE, 0xff);
1246
1247 WCrt(ba, CRT_ID_OVERFLOW_HIGH,
1248 ((VBS & 0x400) ? 0x01 : 0x00) |
1249 ((VT & 0x400) ? 0x02 : 0x00) |
1250 ((VDE & 0x400) ? 0x04 : 0x00) |
1251 ((VSS & 0x400) ? 0x08 : 0x00) |
1252 0x10 |
1253 ((gv->disp_flags & GRF_FLAGS_LACE) ? 0x80 : 0x00));
1254
1255 WCrt(ba, CRT_ID_HOR_OVERFLOW,
1256 ((HT & 0x100) ? 0x01 : 0x00) |
1257 ((HBS & 0x100) ? 0x04 : 0x00) |
1258 ((HSS & 0x100) ? 0x10 : 0x00)
1259 );
1260
1261 /* depth dependent stuff */
1262
1263 WGfx(ba, GCT_ID_GRAPHICS_MODE,
1264 ((TEXT || (gv->depth == 1)) ? 0x00 : 0x40));
1265 WGfx(ba, GCT_ID_MISC, (TEXT ? 0x04 : 0x01));
1266
1267 vgaw(ba, VDAC_MASK, 0xff);
1268 vgar(ba, VDAC_MASK);
1269 vgar(ba, VDAC_MASK);
1270 vgar(ba, VDAC_MASK);
1271 vgar(ba, VDAC_MASK);
1272 switch (gv->depth) {
1273 case 1:
1274 case 4: /* text */
1275 switch(etdtype) {
1276 case SIERRA11483:
1277 case SIERRA15025:
1278 case MUSICDAC:
1279 vgaw(ba, VDAC_MASK, 0);
1280 break;
1281 case ATT20C491:
1282 vgaw(ba, VDAC_MASK, 0x02);
1283 break;
1284 case MERLINDAC:
1285 setMerlinDACmode(ba, 0);
1286 break;
1287 }
1288 HDE = gv->disp_width / 16;
1289 break;
1290 case 8:
1291 switch(etdtype) {
1292 case SIERRA11483:
1293 case SIERRA15025:
1294 case MUSICDAC:
1295 vgaw(ba, VDAC_MASK, 0);
1296 break;
1297 case ATT20C491:
1298 vgaw(ba, VDAC_MASK, 0x02);
1299 break;
1300 case MERLINDAC:
1301 setMerlinDACmode(ba, 0);
1302 break;
1303 }
1304 HDE = gv->disp_width / 8;
1305 break;
1306 case 15:
1307 switch(etdtype) {
1308 case SIERRA11483:
1309 case SIERRA15025:
1310 case MUSICDAC:
1311 case ATT20C491:
1312 vgaw(ba, VDAC_MASK, 0xa0);
1313 break;
1314 case MERLINDAC:
1315 setMerlinDACmode(ba, 0xa0);
1316 break;
1317 }
1318 HDE = gv->disp_width / 4;
1319 break;
1320 case 16:
1321 switch(etdtype) {
1322 case SIERRA11483:
1323 vgaw(ba, VDAC_MASK, 0); /* illegal mode! */
1324 break;
1325 case SIERRA15025:
1326 vgaw(ba, VDAC_MASK, 0xe0);
1327 break;
1328 case MUSICDAC:
1329 case ATT20C491:
1330 vgaw(ba, VDAC_MASK, 0xc0);
1331 break;
1332 case MERLINDAC:
1333 setMerlinDACmode(ba, 0xe0);
1334 break;
1335 }
1336 HDE = gv->disp_width / 4;
1337 break;
1338 case 24:
1339 switch(etdtype) {
1340 case SIERRA11483:
1341 vgaw(ba, VDAC_MASK, 0); /* illegal mode! */
1342 break;
1343 case SIERRA15025:
1344 vgaw(ba, VDAC_MASK, 0xe1);
1345 break;
1346 case MUSICDAC:
1347 case ATT20C491:
1348 vgaw(ba, VDAC_MASK, 0xe0);
1349 break;
1350 case MERLINDAC:
1351 setMerlinDACmode(ba, 0xf0);
1352 break;
1353 }
1354 HDE = (gv->disp_width / 8) * 3;
1355 break;
1356 case 32:
1357 switch(etdtype) {
1358 case SIERRA11483:
1359 case MUSICDAC:
1360 case ATT20C491:
1361 vgaw(ba, VDAC_MASK, 0); /* illegal mode! */
1362 break;
1363 case SIERRA15025:
1364 vgaw(ba, VDAC_MASK, 0x61);
1365 break;
1366 case MERLINDAC:
1367 setMerlinDACmode(ba, 0xb0);
1368 break;
1369 }
1370 HDE = gv->disp_width / 2;
1371 break;
1372 }
1373 WAttr(ba, ACT_ID_ATTR_MODE_CNTL, (TEXT ? 0x0a : 0x01));
1374 WAttr(ba, 0x20 | ACT_ID_COLOR_PLANE_ENA,
1375 (gv->depth == 1) ? 0x01 : 0x0f);
1376
1377 WCrt(ba, CRT_ID_OFFSET, HDE);
1378 vgaw(ba, CRT_ADDRESS, CRT_ID_HOR_OVERFLOW);
1379 vgaw(ba, CRT_ADDRESS_W,
1380 (vgar(ba, CRT_ADDRESS_R) & 0x7f)
1381 | ((HDE & 0x100) ? 0x80: 0x00));
1382
1383 /* text initialization */
1384 if (TEXT) {
1385 et_inittextmode(gp);
1386 }
1387
1388 WSeq(ba, SEQ_ID_CLOCKING_MODE, 0x01);
1389
1390 /* Pass-through */
1391 RegOffpass(ba);
1392
1393 return (1);
1394 }
1395
1396
1397 void
1398 et_inittextmode(struct grf_softc *gp)
1399 {
1400 struct grfettext_mode *tm = (struct grfettext_mode *) gp->g_data;
1401 volatile unsigned char *ba = gp->g_regkva;
1402 volatile unsigned char *fb = gp->g_fbkva;
1403 volatile unsigned char *c;
1404 unsigned char *f, y;
1405 unsigned short z;
1406
1407
1408 /*
1409 * load text font into beginning of display memory. Each character
1410 * cell is 32 bytes long (enough for 4 planes)
1411 */
1412
1413 SetTextPlane(ba, 0x02);
1414 et_memset(fb, 0, 256 * 32);
1415 c = fb + (32 * tm->fdstart);
1416 f = tm->fdata;
1417 for (z = tm->fdstart; z <= tm->fdend; z++, c += (32 - tm->fy))
1418 for (y = 0; y < tm->fy; y++)
1419 *c++ = *f++;
1420
1421 /* clear out text/attr planes (three screens worth) */
1422
1423 SetTextPlane(ba, 0x01);
1424 et_memset(fb, 0x07, tm->cols * tm->rows * 3);
1425 SetTextPlane(ba, 0x00);
1426 et_memset(fb, 0x20, tm->cols * tm->rows * 3);
1427
1428 /* print out a little init msg */
1429
1430 c = fb + (tm->cols - 16);
1431 strcpy(__UNVOLATILE(c), "TSENG");
1432 c[5] = 0x20;
1433
1434 /* set colors (B&W) */
1435
1436 switch(ettype) {
1437 case MERLIN:
1438 vgaw(ba, MERLIN_VDAC_INDEX, 0);
1439 for (z = 0; z < 256; z++) {
1440 y = (z & 1) ? ((z > 7) ? 2 : 1) : 0;
1441
1442 vgaw(ba, MERLIN_VDAC_COLORS, etconscolors[y][0]);
1443 vgaw(ba, MERLIN_VDAC_COLORS, etconscolors[y][1]);
1444 vgaw(ba, MERLIN_VDAC_COLORS, etconscolors[y][2]);
1445 }
1446 break;
1447 default:
1448 vgaw(ba, VDAC_ADDRESS_W, 0);
1449 for (z = 0; z < 256; z++) {
1450 y = (z & 1) ? ((z > 7) ? 2 : 1) : 0;
1451
1452 vgaw(ba, VDAC_DATA + ((ettype == DOMINO) ? 0x0fff : 0),
1453 etconscolors[y][0] >> etcmap_shift);
1454 vgaw(ba, VDAC_DATA + ((ettype == DOMINO) ? 0x0fff : 0),
1455 etconscolors[y][1] >> etcmap_shift);
1456 vgaw(ba, VDAC_DATA + ((ettype == DOMINO) ? 0x0fff : 0),
1457 etconscolors[y][2] >> etcmap_shift);
1458 }
1459 break;
1460 }
1461 }
1462
1463
1464 void
1465 et_memset(volatile unsigned char *d, unsigned char c, int l)
1466 {
1467 for (; l > 0; l--)
1468 *d++ = c;
1469 }
1470
1471
1472 static int
1473 et_getControllerType(struct grf_softc *gp)
1474 {
1475 volatile unsigned char *ba = gp->g_regkva; /* register base */
1476 volatile unsigned char *mem = gp->g_fbkva; /* memory base */
1477 volatile unsigned char *mmu = mem + MMU_APERTURE0; /* MMU aperture 0 base */
1478
1479 *mem = 0;
1480
1481 /* make ACL visible */
1482 if (ettype == MERLIN) {
1483 WCrt(ba, CRT_ID_VIDEO_CONFIG1, 0xbb);
1484 } else {
1485 WCrt(ba, CRT_ID_VIDEO_CONFIG1, 0xfb);
1486 }
1487
1488 WIma(ba, IMA_PORTCONTROL, 0x01);
1489
1490 *((volatile unsigned long *)mmu) = 0;
1491 *(mem + 0x13) = 0x38;
1492
1493 *mmu = 0xff;
1494
1495 /* hide ACL */
1496 WIma(ba, IMA_PORTCONTROL, 0x00);
1497
1498 if (ettype == MERLIN) {
1499 WCrt(ba, CRT_ID_VIDEO_CONFIG1, 0x93);
1500 } else {
1501 WCrt(ba, CRT_ID_VIDEO_CONFIG1, 0xd3);
1502 }
1503 return ((*mem == 0xff) ? ETW32 : ET4000);
1504 }
1505
1506
1507 static int
1508 et_getDACType(struct grf_softc *gp)
1509 {
1510 volatile unsigned char *ba = gp->g_regkva;
1511 union {
1512 int tt;
1513 char cc[4];
1514 } check;
1515
1516 /* check for Sierra SC 15025 */
1517
1518 /* We MUST do 4 HW reads to switch into command mode */
1519 if (vgar(ba, HDR)); if (vgar(ba, HDR)); if (vgar(ba, HDR)); if (vgar(ba, HDR));
1520 vgaw(ba, VDAC_COMMAND, 0x10); /* set ERPF */
1521
1522 vgaw(ba, VDAC_XINDEX, 9);
1523 check.cc[0] = vgar(ba, VDAC_XDATA);
1524 vgaw(ba, VDAC_XINDEX, 10);
1525 check.cc[1] = vgar(ba, VDAC_XDATA);
1526 vgaw(ba, VDAC_XINDEX, 11);
1527 check.cc[2] = vgar(ba, VDAC_XDATA);
1528 vgaw(ba, VDAC_XINDEX, 12);
1529 check.cc[3] = vgar(ba, VDAC_XDATA);
1530
1531 if (vgar(ba, HDR)); if (vgar(ba, HDR)); if (vgar(ba, HDR)); if (vgar(ba, HDR));
1532 vgaw(ba, VDAC_COMMAND, 0x00); /* clear ERPF */
1533
1534 if (check.tt == 0x533ab141) {
1535 if (vgar(ba, HDR)); if (vgar(ba, HDR)); if (vgar(ba, HDR)); if (vgar(ba, HDR));
1536 vgaw(ba, VDAC_COMMAND, 0x10); /* set ERPF */
1537
1538 /* switch to 8 bits per color */
1539 vgaw(ba, VDAC_XINDEX, 8);
1540 vgaw(ba, VDAC_XDATA, 1);
1541 /* do not shift color values */
1542 etcmap_shift = 0;
1543
1544 if (vgar(ba, HDR)); if (vgar(ba, HDR)); if (vgar(ba, HDR)); if (vgar(ba, HDR));
1545 vgaw(ba, VDAC_COMMAND, 0x00); /* clear ERPF */
1546
1547 vgaw(ba, VDAC_MASK, 0xff);
1548 return (SIERRA15025);
1549 }
1550
1551 /* check for MUSIC DAC */
1552
1553 if (vgar(ba, HDR)); if (vgar(ba, HDR)); if (vgar(ba, HDR)); if (vgar(ba, HDR));
1554 vgaw(ba, VDAC_COMMAND, 0x02); /* set some strange MUSIC mode (???) */
1555
1556 vgaw(ba, VDAC_XINDEX, 0x01);
1557 if (vgar(ba, VDAC_XDATA) == 0x01) {
1558 /* shift color values by 2 */
1559 etcmap_shift = 2;
1560
1561 vgaw(ba, VDAC_MASK, 0xff);
1562 return (MUSICDAC);
1563 }
1564
1565 /* check for AT&T ATT20c491 DAC (crest) */
1566 if (vgar(ba, HDR)); if (vgar(ba, HDR)); if (vgar(ba, HDR)); if (vgar(ba, HDR));
1567 vgaw(ba, HDR, 0xff);
1568 vgaw(ba, VDAC_MASK, 0x01);
1569 if (vgar(ba, HDR)); if (vgar(ba, HDR)); if (vgar(ba, HDR)); if (vgar(ba, HDR));
1570 if (vgar(ba, HDR) == 0xff) {
1571 /* do not shift color values */
1572 etcmap_shift = 0;
1573
1574 vgaw(ba, VDAC_MASK, 0xff);
1575 return (ATT20C491);
1576 }
1577
1578 /* restore PowerUp settings (crest) */
1579 if (vgar(ba, HDR)); if (vgar(ba, HDR)); if (vgar(ba, HDR)); if (vgar(ba, HDR));
1580 vgaw(ba, HDR, 0x00);
1581
1582 /*
1583 * nothing else found, so let us pretend it is a stupid
1584 * Sierra SC 11483
1585 */
1586
1587 /* shift color values by 2 */
1588 etcmap_shift = 2;
1589
1590 vgaw(ba, VDAC_MASK, 0xff);
1591 return (SIERRA11483);
1592 }
1593
1594 #endif /* NGRFET */
NetBSD on the FriendlyARM MINI2440