![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to blit.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / i386 / i386at|
Return to blit.c CVS log | Up to [GnuMach] / Gnu-Mach / i386 / i386at |
1.1 root 1: /*
2: * Mach Operating System
3: * Copyright (c) 1991,1990,1989 Carnegie Mellon University
4: * All Rights Reserved.
5: *
6: * Permission to use, copy, modify and distribute this software and its
7: * documentation is hereby granted, provided that both the copyright
8: * notice and this permission notice appear in all copies of the
9: * software, derivative works or modified versions, and any portions
10: * thereof, and that both notices appear in supporting documentation.
11: *
12: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
13: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
14: * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
15: *
16: * Carnegie Mellon requests users of this software to return to
17: *
18: * Software Distribution Coordinator or [email protected]
19: * School of Computer Science
20: * Carnegie Mellon University
21: * Pittsburgh PA 15213-3890
22: *
23: * any improvements or extensions that they make and grant Carnegie Mellon
24: * the rights to redistribute these changes.
25: */
26:
27: /* **********************************************************************
28: File: blit.c
29: Description: Device Driver for Bell Tech Blit card
30:
31: $ Header: $
32:
33: Copyright Ing. C. Olivetti & C. S.p.A. 1988, 1989.
34: All rights reserved.
35: ********************************************************************** */
36: /*
37: Copyright 1988, 1989 by Olivetti Advanced Technology Center, Inc.,
38: Cupertino, California.
39:
40: All Rights Reserved
41:
42: Permission to use, copy, modify, and distribute this software and
43: its documentation for any purpose and without fee is hereby
44: granted, provided that the above copyright notice appears in all
45: copies and that both the copyright notice and this permission notice
46: appear in supporting documentation, and that the name of Olivetti
47: not be used in advertising or publicity pertaining to distribution
48: of the software without specific, written prior permission.
49:
50: OLIVETTI DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE
51: INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS,
52: IN NO EVENT SHALL OLIVETTI BE LIABLE FOR ANY SPECIAL, INDIRECT, OR
53: CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
54: LOSS OF USE, DATA OR PROFITS, WHETHER IN ACTION OF CONTRACT,
55: NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUR OF OR IN CONNECTION
56: WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
57: */
58:
59: /*
60: Copyright 1988, 1989 by Intel Corporation, Santa Clara, California.
61:
62: All Rights Reserved
63:
64: Permission to use, copy, modify, and distribute this software and
65: its documentation for any purpose and without fee is hereby
66: granted, provided that the above copyright notice appears in all
67: copies and that both the copyright notice and this permission notice
68: appear in supporting documentation, and that the name of Intel
69: not be used in advertising or publicity pertaining to distribution
70: of the software without specific, written prior permission.
71:
72: INTEL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE
73: INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS,
74: IN NO EVENT SHALL INTEL BE LIABLE FOR ANY SPECIAL, INDIRECT, OR
75: CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
76: LOSS OF USE, DATA OR PROFITS, WHETHER IN ACTION OF CONTRACT,
77: NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
78: WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
79: */
80:
81: #ifdef MACH_KERNEL
82: #include <sys/types.h>
83: #include <device/errno.h>
84: #else MACH_KERNEL
85: #include <sys/types.h>
86: #include <sys/errno.h>
87: #include <sys/param.h>
88: #include <sys/dir.h>
89: #include <sys/signal.h>
90: #include <sys/user.h>
91: #endif MACH_KERNEL
92: #include <vm/vm_kern.h>
93: #include <mach/vm_param.h>
94: #include <machine/machspl.h>
95:
96: #include <i386at/blitreg.h>
97: #include <i386at/blitvar.h>
98: #include <i386at/blituser.h>
99: #include <i386at/kd.h>
100: #include <i386at/kdsoft.h>
101:
102: #include <blit.h>
103:
104:
105: /*
106: * This driver really only supports 1 card, though parts of it were
107: * written to support multiple cards. If you want to finish the job
108: * and really support multiple cards, then you'll have to:
109: *
110: * (1) make sure that driver functions pass around a pointer telling
111: * which card they're talking about.
112: *
113: * (2) coordinate things with the kd driver, so that one card is used
114: * for the console and the other is simply an additional display.
115: */
116: #define MAXBLITS 1
117:
118: #if NBLIT > MAXBLITS
119: /* oh, no, you don't want to do this...; */
120:
121: #else
122: #if NBLIT > 0
123:
124: #define AUTOINIT 0
125:
126: /*
127: * Forward Declarations
128: */
129: static tiledesc();
130: static loadall();
131:
132: #if AUTOINIT
133: int blitattach(), blitprobe();
134: #endif
135:
136: int blitioctl(), blitopen(), blitclose(), blitmmap();
137:
138:
139: static void setstatus();
140: #define CARD_RESET 0
141: #define CARD_MAPPED 1
142: #define CARD_MAYBE_PRESENT 2
143: #define CARD_PRESENT 3
144: #define BIU_INIT 4
145: #define UNUSED1 5
146: #define DP_INIT 6
147: #define UNUSED2 7
148:
149:
150: #if AUTOINIT
151: struct mb_device *blitinfo[NBLIT];
152:
153: struct mb_driver blitdriver = {
154: blitprobe,
155: 0, /* slave routine */
156: blitattach,
157: 0, 0, 0, /* go, done, intr routines */
158: BLIT_MAPPED_SIZE,
159: "blit", blitinfo, /* device info */
160: 0, 0, /* no controller */
161: 0 /* no flags */
162: /* rest zeros */
163: };
164: #endif /* AUTOINIT */
165:
166:
167: /*
168: * Per-card bookkeeping information for driver.
169: *
170: * "scrstrip" and "dpctlregs" point to data areas that are passed to
171: * the Display Processor. They are allocated out of the spare
172: * graphics memory. "scrstrip" is used to describe an entire screen.
173: * "dpctlregs" contains assorted parameters for the display
174: * controller.
175: *
176: * "firstfree" is an offset into the graphics memory. Memory starting
177: * there can be allocated by users.
178: */
179:
180: struct blitsoft {
181: struct blitdev *blt; /* ptr to mapped card */
182: caddr_t physaddr; /* start of mapped card */
183: boolean_t open; /* is device open? */
184: struct screen_descrip *scrstrip;
185: DPCONTROLBLK *dpctlregs;
186: int firstfree;
187: } blitsoft[NBLIT];
188:
189:
190: /*
191: * The following array contains the initial settings for
192: * the Display Processor Control Block Registers.
193: * The video timing signals in this array are for the
194: * Bell Technologies Blit Express running in 1664 x 1200 x 1 mode.
195: * Please treat as read-only.
196: */
197:
198: DPCONTROLBLK blit_mparm = {
199: DP_DSP_ON, /* video status */
200: 0x00ff, /* interrupt mask - all disabled */
201: 0x0010, /* trip point */
202: 0x00ff, /* frame interrupt interval */
203: 0x0000, /* reserved */
204: CRTM_NONINTER | CRTM_SUPHIGH_SPEED, /* CRT controller mode */
205: 41, /* horizontal synch stop */
206: 57, /* horiz field start */
207: 265, /* horiz field stop */
208: 265, /* line length */
209: 15, /* vert synch stop */
210: 43, /* vert field start */
211: 1243, /* vert field stop */
212: 1244, /* frame length */
213: 0x0000, 0x0000, /* descriptor pointer */
214: 0x0000, /* reserved */
215: 0x0101, /* x, y zoom factors */
216: 0x0000, /* FldColor */
217: 0x00ff, /* BdrColor */
218: 0x0000, /* 1Bpp Pad */
219: 0x0000, /* 2Bpp Pad */
220: 0x0000, /* 4Bpp Pad */
221: DP_CURSOR_CROSSHAIR, /* cursor style & mode */
222: 0x00A0, 0x0050, /* cursor x & y loc. */
223: /* cursor pattern */
224: 0xfffe, 0xfffc, 0xc018, 0xc030, 0xc060, 0xc0c0, 0xc0c0, 0xc060,
225: 0xc430, 0xce18, 0xdb0c, 0xf186, 0xe0c3, 0xc066, 0x803c, 0x0018
226: };
227:
228: void blitreboot();
229:
230: /***********
231: *
232: * Initialization.
233: *
234: ***********/
235:
236:
237: /*
238: * Probe - is the board there?
239: *
240: * in: reg = start of mapped Blit memory.
241: *
242: * out: returns size of mapped Blit memory if the board is present,
243: * 0 otherwise.
244: *
245: * effects: if the board is present, it is reset and left visible in
246: * Unix mode.
247: */
248:
249: #if AUTOINIT
250: /*ARGSUSED*/
251: int
252: blitprobe(reg, unit)
253: caddr_t reg;
254: int unit;
255: {
256: struct blitdev *blt = (struct blitdev *)reg;
257:
258: if (blit_present())
259: return(BLIT_MAPPED_SIZE); /* go */
260: else
261: return(0); /* no-go */
262: }
263: #endif /* AUTOINIT */
264:
265:
266: /*
267: * Temporary initialization routine. This will go away when we have
268: * autoconfig.
269: */
270:
271: blitinit()
272: {
273: if (!blit_present())
274: return;
275:
276: blit_init();
277: }
278:
279:
280: /*
281: * Allocate needed objects from Blit's memory.
282: */
283: blit_memory_init(bs)
284: struct blitsoft *bs;
285: {
286: struct blitdev *blt = bs->blt;
287: struct blitmem *bm = (struct blitmem *)blt->graphmem;
288: u_char *p = bm->spare;
289:
290: if ((int)p % 2 == 1)
291: ++p;
292:
293: bs->scrstrip = (struct screen_descrip *)p;
294: p += sizeof(struct screen_descrip);
295: if ((int)p % 2 == 1)
296: ++p;
297:
298: bs->dpctlregs = (DPCONTROLBLK *)p;
299: p += sizeof(DPCONTROLBLK);
300: if ((int)p % 2 == 1)
301: ++p;
302:
303: /*
304: * Note: if you use the 786 graphics processor for character
305: * processing, you should copy the font from the ROM into
306: * graphics memory and change font_start to point to it.
307: * Otherwise, the 786 will have problems accessing the font.
308: */
309:
310: bs->firstfree = p - blt->graphmem;
311: }
312:
313:
314: /*
315: * Reset the Blit board and leave it visible.
316: */
317:
318: blit_reset_board()
319: {
320: union blit_config_reg config;
321:
322: config.byte = inb(BLIT_CONFIG_ADDR);
323: config.reg.reset = 1;
324: outb(BLIT_CONFIG_ADDR, config.byte);
325: config.reg.reset = 0;
326: config.reg.mode = BLIT_UNIX_MODE;
327: config.reg.invisible = BLIT_VISIBLE;
328: outb(BLIT_CONFIG_ADDR, config.byte);
329: setstatus(CARD_RESET);
330: }
331:
332:
333: #if AUTOINIT
334: /*
335: * Attach - finish initialization by setting up the 786.
336: */
337:
338: blitattach(md)
339: struct mb_device *md;
340: {
341: struct blitdev *blt = (struct blitdev *)md->md_addr;
342:
343: blit_init(xyz);
344: }
345: #endif /* AUTOINIT */
346:
347:
348: /*
349: * Initialize Bus Interface Unit.
350: */
351:
352: init_biu(blt)
353: struct blitdev *blt;
354: {
355: WRITEREG8(blt, INTER_RELOC, 0);
356: WRITEREG8(blt, BIU_CONTROL, BIU_16BIT);
357:
358: /* WRITEREG16(blt, DRAM_REFRESH, 0x003f); */
359: WRITEREG16(blt, DRAM_REFRESH, 0x0018); /* refresh rate */
360: WRITEREG16(blt, DRAM_CONTROL,
361: MEMROWS1 | FASTPG_INTERLV | HEIGHT_256K);
362: WRITEREG16(blt, DP_PRIORITY, (7 << 3) | 7); /* max pri */
363: WRITEREG16(blt, GP_PRIORITY, (1 << 3) | 1); /* almost min pri */
364: WRITEREG16(blt, EXT_PRIORITY, 5 << 3);
365:
366: /* now freeze the settings */
367: WRITEREG16(blt, BIU_CONTROL, BIU_16BIT | BIU_WP1);
368:
369: /* Put graphics processor into Poll state. */
370: WRITEREG16(blt, GP_OPCODE_REG, (OP_LINK|GECL));
371: }
372:
373:
374: /*
375: * Initialize the Display Processor.
376: * XXX - assumes only 1 card is installed, assumes monochrome display.
377: */
378:
379: init_dp(bs)
380: struct blitsoft *bs;
381: {
382: struct blitdev *blt = bs->blt;
383: struct blitmem *bm = (struct blitmem *)blt->graphmem;
384:
385: /*
386: * Set up strip header and tile descriptor for the whole
387: * screen. It's not clear why the C bit should be turned on,
388: * but it seems to get rid of the nasty flickering you can get
389: * by positioning an xterm window along the top of the screen.
390: */
391: bs->scrstrip->strip.lines = BLIT_MONOHEIGHT - 1;
392: bs->scrstrip->strip.linkl = 0;
393: bs->scrstrip->strip.linkh = 0;
394: bs->scrstrip->strip.tiles = DP_C_BIT | (1 - 1);
395: tiledesc(&bs->scrstrip->tile,
396: 0, 0, /* x, y */
397: BLIT_MONOWIDTH, /* width of strip */
398: BLIT_MONOWIDTH, /* width of bitmap */
399: VM_TO_ADDR786(bm->fb.mono_fb, blt), /* the actual bitmap */
400: 1); /* bits per pixel */
401:
402: /* Copy into DP register block. */
403: *(bs->dpctlregs) = blit_mparm;
404: bs->dpctlregs->descl = DP_ADDRLOW(VM_TO_ADDR786(bs->scrstrip, blt));
405: bs->dpctlregs->desch = DP_ADDRHIGH(VM_TO_ADDR786(bs->scrstrip, blt));
406:
407: /* Load the DP with the register block */
408: loadall(blt, bs->dpctlregs);
409: }
410:
411:
412: /*
413: * Fill in a tile descriptor.
414: */
415:
416: static
417: tiledesc(tile, x, y, w, ww, adx, bpp)
418: TILEDESC *tile; /* pointer to tile descriptor */
419: int x; /* starting x in bitmap */
420: int y; /* starting y in bitmap */
421: int w; /* width of strip (in bits_) */
422: int ww; /* actual width of bitmap (bits) */
423: addr786_t adx; /* start of bitmap */
424: int bpp; /* bits per pixel */
425: {
426: u_short bm_width;
427: short rghtp;
428: short adr_left, adr_right;
429: addr786_t bmstadr;
430: u_short start_stop_bit;
431:
432: bm_width = 2 * (((ww + 1) * bpp) / 16);
433: rghtp = x + w - 1;
434: adr_left = ((x * bpp) / 16) * 2;
435: adr_right = ((rghtp * bpp) / 16) * 2;
436: bmstadr = (ww * y) + adr_left + (int)adx;
437: start_stop_bit = ((((16 - 1) - ((x * bpp) % 16)) << 4) +
438: ((16 - ((rghtp + 1) * bpp) % 16) % 16) +
439: (bpp << 8));
440:
441: tile->bitmapw = bm_width;
442: tile->meml = DP_ADDRLOW(bmstadr);
443: tile->memh = DP_ADDRHIGH(bmstadr);
444: tile->bppss = start_stop_bit;
445: tile->fetchcnt = adr_right - adr_left;
446: tile->flags = 0;
447: }
448:
449:
450: /*
451: * Cause the Display Processor to load its Control Registers from
452: * "vm_addr".
453: */
454:
455: static
456: loadall(blt, vm_addr)
457: struct blitdev *blt;
458: DPCONTROLBLK *vm_addr;
459: {
460: addr786_t blit_addr = VM_TO_ADDR786(vm_addr, blt);
461: int i;
462:
463: /* set up dp address */
464: WRITEREG16(blt, DP_PARM1_REG, DP_ADDRLOW(blit_addr));
465: WRITEREG16(blt, DP_PARM2_REG, DP_ADDRHIGH(blit_addr));
466:
467: /* set blanking video */
468: WRITEREG16(blt, DEF_VIDEO_REG, 0);
469:
470: /* load opcode to start dp */
471: WRITEREG16(blt, DP_OPCODE_REG, DP_LOADALL);
472:
473: /* wait for acceptance */
474: for (i = 0; i < DP_RDYTIMEOUT; ++i)
475: if (READREG(blt, DP_OPCODE_REG) & DECL)
476: break;
477:
478: if (i >= DP_RDYTIMEOUT) {
479: printf("Blit Display Processor timeout (loading registers)\n");
480: hang:
481: goto hang;
482: }
483:
484: #ifdef notdef
485: /* wait for acceptance */
486: CDELAY((READREG(blt, DP_OPCODE_REG) & DECL) != 0, DP_RDYTIMEOUT);
487: if ((READREG(blt, DP_OPCODE_REG) & DECL) == 0) {
488: printf("Blit Display Processor timeout (loading registers)\n");
489: hang:
490: goto hang;
491: }
492: #endif /* notdef */
493: }
494:
495:
496: /*
497: * blit_present: returns YES if Blit is present. For the first call,
498: * the hardware is probed. After that, a flag is used.
499: * Sets blitsoft[0].blt and blitsoft[0].physaddr.
500: */
501:
502: #define TEST_BYTE 0xa5 /* should not be all 0's or 1's */
503:
504: boolean_t
505: blit_present()
506: {
507: static boolean_t present = FALSE;
508: static boolean_t initialized = FALSE;
509: struct blitdev *blt;
510: boolean_t blit_rom_ok();
511: struct blitdev *mapblit();
512: void freeblit();
513:
514: /*
515: * We set "initialized" early on so that if the Blit init. code
516: * fails, kdb will still be able to use the EGA or VGA display
517: * (if present).
518: */
519: if (initialized)
520: return(present);
521: initialized = TRUE;
522:
523: blit_reset_board();
524: blt = mapblit((caddr_t)BLIT_BASE_ADDR, BLIT_MAPPED_SIZE);
525: setstatus(CARD_MAPPED);
526: if (blt == NULL)
527: panic("blit: can't map display");
528: blt->graphmem[0] = TEST_BYTE;
529: present = FALSE;
530: if (blt->graphmem[0] == TEST_BYTE) {
531: setstatus(CARD_MAYBE_PRESENT);
532: present = blit_rom_ok(blt);
533: }
534: if (present) {
535: blitsoft[0].blt = blt;
536: blitsoft[0].physaddr = (caddr_t)BLIT_BASE_ADDR;
537: setstatus(CARD_PRESENT);
538: }
539: else
540: freeblit((vm_offset_t)blt, BLIT_MAPPED_SIZE);
541: return(present);
542: }
543:
544: #undef TEST_BYTE
545:
546:
547: /*
548: * mapblit: map the card into kernel vm and return the (virtual)
549: * address.
550: */
551: struct blitdev *
552: mapblit(physaddr, length)
553: caddr_t physaddr; /* start of card */
554: int length; /* num bytes to map */
555: {
556: vm_offset_t vmaddr;
557: #ifdef MACH_KERNEL
558: vm_offset_t io_map();
559: #else MACH_KERNEL
560: vm_offset_t pmap_map_bd();
561: #endif MACH_KERNEL
562:
563: if (physaddr != (caddr_t)trunc_page(physaddr))
564: panic("Blit card not on page boundary");
565:
566: #ifdef MACH_KERNEL
567: vmaddr = io_map((vm_offset_t)physaddr, length);
568: if (vmaddr == 0)
569: #else MACH_KERNEL
570: if (kmem_alloc_pageable(kernel_map,
571: &vmaddr, round_page(BLIT_MAPPED_SIZE))
572: != KERN_SUCCESS)
573: #endif MACH_KERNEL
574: panic("can't alloc VM for Blit card");
575:
576: (void)pmap_map_bd(vmaddr, (vm_offset_t)physaddr,
577: (vm_offset_t)physaddr+length,
578: VM_PROT_READ | VM_PROT_WRITE);
579: return((struct blitdev *)vmaddr);
580: }
581:
582:
583: /*
584: * freeblit: free card from memory.
585: * XXX - currently a no-op.
586: */
587: void
588: freeblit(va, length)
589: vm_offset_t va; /* virt addr start of card */
590: int length;
591: {
592: }
593:
594:
595: /*
596: * blit_init: initialize globals & hardware, and set cursor. Could be
597: * called twice, once as part of kd initialization and once as part of
598: * blit initialization. Should not be called before blit_present() is
599: * called.
600: */
601:
602: void
603: blit_init()
604: {
605: static boolean_t initialized = FALSE;
606: struct blitmem *gmem; /* start of blit graphics memory */
607: int card;
608: void getfontinfo(), clear_blit();
609:
610: if (initialized)
611: return;
612:
613: for (card = 0; card < NBLIT; ++card) {
614: if (card > 0) {
615: blitsoft[card].blt = NULL;
616: blitsoft[card].physaddr = NULL;
617: }
618: blitsoft[card].open = FALSE;
619: blitsoft[card].scrstrip = NULL;
620: blitsoft[card].dpctlregs = NULL;
621: blitsoft[card].firstfree = 0;
622: }
623:
624: /*
625: * blit_memory_init allocates memory used by the Display Processor,
626: * so it comes before the call to init_dp. blit_memory_init
627: * potentially copies the font from ROM into the graphics memory,
628: * so it comes after the call to getfontinfo.
629: */
630: getfontinfo(blitsoft[0].blt); /* get info & check assumptions */
631: blit_memory_init(&blitsoft[0]);
632:
633: /* init 786 */
634: init_biu(blitsoft[0].blt);
635: setstatus(BIU_INIT);
636: init_dp(&blitsoft[0]);
637: setstatus(DP_INIT);
638:
639: gmem = (struct blitmem *)blitsoft[0].blt->graphmem;
640: vid_start = gmem->fb.mono_fb;
641: kd_lines = 25;
642: kd_cols = 80;
643: kd_attr = KA_NORMAL;
644:
645: /*
646: * Use generic bitmap routines, no 786 assist (see
647: * blit_memory_init).
648: */
649: kd_dput = bmpput;
650: kd_dmvup = bmpmvup;
651: kd_dmvdown = bmpmvdown;
652: kd_dclear = bmpclear;
653: kd_dsetcursor = bmpsetcursor;
654: kd_dreset = blitreboot;
655:
656: clear_blit(blitsoft[0].blt);
657: (*kd_dsetcursor)(0);
658:
659: initialized = TRUE;
660: }
661:
662:
663: /*
664: * blit_rom_ok: make sure we're looking at the ROM for a monochrome
665: * Blit.
666: */
667:
668: boolean_t
669: blit_rom_ok(blt)
670: struct blitdev *blt;
671: {
672: short magic;
673: short bpp;
674:
675: magic = READROM(blt->eprom, EP_MAGIC1);
676: if (magic != EP_MAGIC1_VAL) {
677: #ifdef notdef
678: printf("blit: magic1 bad (0x%x)\n", magic);
679: #endif
680: return(FALSE);
681: }
682: magic = READROM(blt->eprom, EP_MAGIC2);
683: if (magic != EP_MAGIC2_VAL) {
684: #ifdef notdef
685: printf("blit: magic2 bad (0x%x)\n", magic);
686: #endif
687: return(FALSE);
688: }
689: bpp = READROM(blt->eprom, EP_BPP);
690: if (bpp != 1) {
691: #ifdef notdef
692: printf("blit: not monochrome board (bpp = 0x%x)\n", bpp);
693: #endif
694: return(FALSE);
695: }
696:
697: return(TRUE);
698: }
699:
700:
701: /*
702: * getfontinfo: get information about the font and make sure that
703: * our simplifying assumptions are valid.
704: */
705:
706: void
707: getfontinfo(blt)
708: struct blitdev *blt;
709: {
710: u_char *rom = blt->eprom;
711: short fontoffset;
712: short pick_cursor_height();
713:
714: fb_width = BLIT_MONOWIDTH;
715: fb_height = BLIT_MONOHEIGHT;
716: chars_in_font = READROM(rom, EP_NUMCHARS);
717: char_width = READROM(rom, EP_CHARWIDTH);
718: char_height = READROM(rom, EP_CHARHEIGHT);
719: fontoffset = READROM(rom, EP_FONTSTART);
720: xstart = READROM(rom, EP_XSTART);
721: ystart = READROM(rom, EP_YSTART);
722: char_black = BLIT_BLACK_BYTE;
723: char_white = BLIT_WHITE_BYTE;
724:
725: font_start = rom + fontoffset;
726:
727: /*
728: * Check byte-alignment assumption.
729: * XXX - does it do any good to panic when initializing the
730: * console driver?
731: */
732: if (char_width % 8 != 0)
733: panic("blit: char width not integral num of bytes");
734: if (xstart % 8 != 0) {
735: /* move it to a more convenient location */
736: printf("blit: console corner moved.\n");
737: xstart = 8 * (xstart/8);
738: }
739:
740: cursor_height = pick_cursor_height();
741: char_byte_width = char_width / 8;
742: fb_byte_width = BLIT_MONOWIDTH / 8;
743: font_byte_width = char_byte_width * chars_in_font;
744: }
745:
746:
747: /*
748: * pick_cursor_height: pick a size for the cursor, based on the font
749: * size.
750: */
751:
752: short
753: pick_cursor_height()
754: {
755: int scl_avail; /* scan lines available for console */
756: int scl_per_line; /* scan lines per console line */
757:
758: /*
759: * scan lines avail. = total lines - top margin;
760: * no bottom margin (XXX).
761: */
762: scl_avail = BLIT_MONOHEIGHT - ystart;
763:
764: scl_per_line = scl_avail / kd_lines;
765: if (scl_per_line < char_height)
766: return(1);
767: else
768: return(scl_per_line - char_height);
769: }
770:
771:
772: /*
773: * setstatus: Give a status indication to the user. Ideally, we'd
774: * just set the 3 user-controlled LED's. Unfortunately, that doesn't
775: * seem to work. So, we ring the bell.
776: */
777:
778: static void
779: setstatus(val)
780: int val;
781: {
782: union blit_diag_reg diag;
783:
784: diag.byte = inb(BLIT_DIAG_ADDR);
785: diag.reg.led0 = (val & 1) ? BLIT_LED_ON : BLIT_LED_OFF;
786: diag.reg.led1 = (val & 2) ? BLIT_LED_ON : BLIT_LED_OFF;
787: diag.reg.led2 = (val & 4) ? BLIT_LED_ON : BLIT_LED_OFF;
788: outb(BLIT_DIAG_ADDR, diag.byte);
789:
790: #ifdef DEBUG
791: for (val &= 7; val > 0; val--) {
792: feep();
793: pause();
794: }
795: for (val = 0; val < 10; val++) {
796: pause();
797: }
798: #endif
799: }
800:
801:
802:
803: /***********
804: *
805: * Other (non-initialization) routines.
806: *
807: ***********/
808:
809:
810: /*
811: * Open - Verify that minor device is OK and not in use, then clear
812: * the screen.
813: */
814:
815: /*ARGSUSED*/
816: int
817: blitopen(dev, flag)
818: dev_t dev;
819: int flag;
820: {
821: void clear_blit();
822: int which = minor(dev);
823:
824: if (!blit_present() || which >= NBLIT)
825: return(ENXIO);
826: if (blitsoft[which].open)
827: return(EBUSY);
828:
829: clear_blit(blitsoft[which].blt);
830: blitsoft[which].open = TRUE;
831: return(0); /* ok */
832: }
833:
834:
835: /*
836: * Close - free any kernel memory structures that were allocated while
837: * the device was open (currently none).
838: */
839:
840: /*ARGSUSED*/
841: blitclose(dev, flag)
842: dev_t dev;
843: int flag;
844: {
845: int which = minor(dev);
846:
847: if (!blitsoft[which].open)
848: panic("blit: closing not-open device??");
849: blitsoft[which].open = FALSE;
850: }
851:
852:
853: /*
854: * Mmap.
855: */
856:
857: /*ARGSUSED*/
858: int
859: blitmmap(dev, off, prot)
860: dev_t dev;
861: off_t off;
862: int prot;
863: {
864: if ((u_int) off >= BLIT_MAPPED_SIZE)
865: return(-1);
866:
867: /* Get page frame number for the page to be mapped. */
868: return(i386_btop(blitsoft[minor(dev)].physaddr + off));
869: }
870:
871:
872: /*
873: * Ioctl.
874: */
875:
876: #ifdef MACH_KERNEL
877: io_return_t blit_get_stat(dev, flavor, data, count)
878: dev_t dev;
879: int flavor;
880: int *data; /* pointer to OUT array */
881: unsigned int *count; /* OUT */
882: {
883: int which = minor(dev);
884:
885: switch (flavor) {
886: case BLIT_1ST_UNUSED:
887: if (*count < 1)
888: return (D_INVALID_OPERATION);
889: *data = blitsoft[which].firstfree;
890: *count = 1;
891: break;
892: default:
893: return (D_INVALID_OPERATION);
894: }
895: return (D_SUCCESS);
896: }
897: #else MACH_KERNEL
898: /*ARGSUSED*/
899: int
900: blitioctl(dev, cmd, data, flag)
901: dev_t dev;
902: int cmd;
903: caddr_t data;
904: int flag;
905: {
906: int which = minor(dev);
907: int err = 0;
908:
909: switch (cmd) {
910: case BLIT_1ST_UNUSED:
911: *(int *)data = blitsoft[which].firstfree;
912: break;
913: default:
914: err = ENOTTY;
915: }
916:
917: return(err);
918: }
919: #endif MACH_KERNEL
920:
921: /*
922: * clear_blit: clear blit's screen.
923: */
924:
925: void
926: clear_blit(blt)
927: struct blitdev *blt;
928: {
929: (*kd_dclear)(0, kd_lines*kd_cols, KA_NORMAL);
930: }
931:
932: /*
933: * Put the board into DOS mode in preparation for rebooting.
934: */
935:
936: void
937: blitreboot()
938: {
939: union blit_config_reg config;
940:
941: config.byte = inb(BLIT_CONFIG_ADDR);
942: config.reg.mode = BLIT_DOS_MODE;
943: config.reg.invisible = BLIT_VISIBLE;
944: outb(BLIT_CONFIG_ADDR, config.byte);
945: }
946:
947: #endif /* NBLIT > 0 */
948: #endif /* NBLIT > MAXBLITS */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.