![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to talkbios.asm CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / kernel / FWB2|
Return to talkbios.asm CVS log | Up to [MW Coherent from dump] / coherent / b / kernel / FWB2 |
1.1 root 1: ;------------------------------------------------------------------------------
2: ; Talking BIOS device driver for the AT&T PC6300.
3: ; Copyright (C) Karl Dahlke 1987
4: ; This software may be freely used and distributed
5: ; for any non-profit purpose.
6: ;------------------------------------------------------------------------------
7:
8: ; talkbios.asm: assembly base and support for talking BIOS routines
9:
10:
11: WDFIXLEN equ 4096 ; length of word correction table
12: KBSIZ equ 120 ; length of type ahead keyboard buffer
13: ADDR equ offset DGROUP
14:
15: ; These routines are bundled into a pseudo device driver,
16: ; which is installed at init time.
17: ; The device cannot be meaningfully read or written.
18:
19: ; Compatible with ansi.sys, ctrm, and most other applications.
20:
21: ; Device Driver skeleton taken from public domain,
22: ; written by Frank Whaley.
23:
24: ; The real time interrupt switches stacks,
25: ; since there are a lot of function calls in it,
26: ; and it holds the CPU for quite a while.
27: ; The other interrupts and the device driver
28: ; use the existing stacks. In general, there is very little
29: ; documentation regarding stacks. How much room is required
30: ; for DOS interrupts, worst case? How much room is available on system
31: ; stacks (e.g. when device drivers get control)?
32: ; It makes it difficult to write robust programs.
33: ; Well, MS-DOS drivers seem quite unconcerned about these things, so,
34: ; For now, we just press on.
35: ; The real time interrupt stack tromps right over the
36: ; initialization code, saving memory.
37:
38: ; here come the segments
39: ; segment structure is compatible with microsoft C, small memory model
40: _TEXT segment byte public 'CODE'
41: _TEXT ends
42: ; empty segments, but C uses them, so declare them
43: CONST segment word public 'CONST'
44: CONST ends
45: _BSS segment word public 'BSS'
46: _BSS ends
47: _DATA segment word public 'DATA'
48: _DATA ends
49: _EDATA segment para public 'EDATA'
50: _EDATA ends
51:
52: DGROUP group CONST, _BSS, _DATA, _EDATA
53: assume cs: _TEXT, ds: DGROUP
54:
55:
56: ; make microsoft C/link phase happy (see crt0.asm)
57: public __acrtused
58: __acrtused = 9876h ; funny value not easily matched in SYMDEB
59:
60:
61: _TEXT segment
62:
63: extrn _sdoutchar:near, _sdinkey:near, _sdioctl:near
64: extrn _sdload:near, _sdtime:near, _dosline:near
65: public myds
66:
67: org 0 ; Device drivers start at 0
68:
69: HDR proc far
70: ; Device Header
71: dd -1 ; -> next device
72: dw 0c000h ; attributes: character, ioctl
73: DW strategy ; -> device strategy
74: DW interrupt ; -> device interrupt
75: db "SPEAK$ " ; talking BIOS routines
76:
77: ; the following variables are accessed through cs.
78: rh1ptr label word ; to access by words
79: rhptr dd 0 ; -> Request Header
80: orig_rti dw 0,0 ; original real time interrupt vector
81: orig_kbi dw 0,0 ; original keyboard interrupt vector
82: orig_bkb dw 0,0 ; original bios keyboard interrupt vector
83: orig_bsc dw 0,0 ; original bios screen interrupt vector
84: ; save ss and sp when switching to real time interrupt stack
85: save_ss dw 0
86: save_sp dw 0
87: myds dw 0 ; ds segment when running this system
88: nestrti db 1 ; check for nested real time interrupts
89:
90: ; functions for device driver commands
91: functab label word
92: DW init
93: dw badf
94: dw badf
95: DW ioctl
96: dw nulf, nulf, nulf, nulf, nulf, nulf, nulf, nulf
97:
98:
99:
100: strategy:
101: ; squirrel away pointer to the msdos request
102: ; I don't understand why dos doesn't just call the interrupt routine directly,
103: ; and bypass this intermediate, seemingly unnecessary strategy routine.
104: mov rh1ptr,BX ; save request header ptr
105: mov rh1ptr + 2,ES
106: ret
107:
108: interrupt:
109: ; device driver interrupt routine, *not* a true interrupt routine.
110: ; Perform the action requested by dos,
111: ; request structure is pointed to by rhptr.
112: ; We save all registers, gather relevant information
113: ; from the request header,
114: ; call the appropriate routine,
115: ; restore registers, and return.
116:
117: pushf
118: push ds
119: push es
120: push ax
121: push bx
122: push cx
123: push dx
124: push si
125: push di
126: cld
127: sti
128: mov ds,myds
129:
130: ; get relevant information from request header,
131: ; for the functions to use
132: les di,rhptr
133: mov al,es:[di+2] ; ax = Command Code
134: cbw
135: ; set default status = DONE
136: mov es:[di+3],100h
137: mov cx,es:[di+18]
138: les di,es:[di+14]
139:
140: ; call our functions
141: cmp al,12
142: jb cmdok
143: ; command out of range
144: mov al,2 ; replace with an illegal command
145: cmdok: mov si,offset _TEXT:functab
146: add si,ax
147: add si,ax
148: call cs:[si]
149:
150: pop di
151: pop si
152: pop dx
153: pop cx
154: pop bx
155: pop ax
156: pop es
157: pop ds
158: popf
159: ret
160:
161: HDR endp
162:
163:
164: ; coherent kernel functions
165: cohker proc near
166: public _sphi, _spl, _inb, _outb, _isin, _kalloc
167: public _memcpy, _setivec, _read_t0
168:
169: _read_t0: pushf
170: cli
171: mov al,0
172: out 43h,al
173: out 0e0h,al
174: in al,40h
175: mov ah,al
176: out 0e0h,al
177: in al,40h
178: out 0e0h,al
179: xchg al,ah
180: popf
181: ret
182:
183: ; a simplistic emulation of setivec(), clrivec() is not provided.
184: ; may only be called once, with either 2 or 3.
185: _setivec:
186: push bp
187: mov bp,sp
188: ; change parameters if on com2
189: cmp word ptr [bp+4],4
190: jz oncom1
191: mov intofs,2ch
192: mov irm,0f7h
193: dec eoi
194: oncom1:
195: mov ax,[bp+6]
196: mov ivec_fn,ax
197:
198: ; set interrupt vector
199: xor ax,ax
200: mov es,ax
201: mov bx,intofs
202: mov word ptr es:[bx],offset _TEXT: ih_com
203: mov es:[bx+2],cs
204:
205: in al,21h ;set enable bit on 8259
206: and al,irm
207: nop ; timing
208: nop
209: out 21h,al
210:
211: pop bp
212: ret
213:
214: _sphi: pushf
215: cli
216: pop ax
217: ret
218:
219: _spl: push bp
220: mov bp,sp
221: mov ax,[bp+4]
222: push ax
223: popf
224: pop bp
225: ret
226:
227: _inb: push bp
228: mov bp,sp
229: mov dx,[bp+4]
230: mov ah,0
231: in al,dx
232: pop bp
233: ret
234:
235: _outb: push bp
236: mov bp,sp
237: mov ax,[bp+6]
238: mov dx,[bp+4]
239: out dx,al
240: pop bp
241: ret
242:
243: _memcpy: push bp
244: mov bp,sp
245: push ds
246: pop es
247: push si
248: push di
249: mov si,[bp+6]
250: mov di,[bp+4]
251: mov cx,[bp+8]
252: repz movsb
253: pop di
254: pop si
255: pop bp
256: ret
257:
258: ; store character in our internal BIOS-like keyboard buffer
259: _isin: push bp
260: mov bp,sp
261: pushf
262: cli
263: mov ax,[bp+4]
264: ; -1 means flush the buffer
265: cmp ax,-1
266: jnz isinflush
267: mov bx,ADDR: kbbuf
268: mov kbhead,bx
269: mov kbtail,bx
270: mov ax, 0
271: jmp short endisin
272: isinflush:
273: ; work around an MSDOS bug, control C goes right to the top
274: ; of the input queue, so you can blow away a running program,
275: ; even if you have accidentally typed another character.
276: cmp al,3
277: jnz normchar
278: mov bx,ADDR: kbbuf
279: mov kbhead,bx
280: mov kbtail,bx
281: normchar: mov bx,kbhead
282: mov [bx],ax
283: inc bx
284: inc bx
285: cmp bx,ADDR: kbbuf+KBSIZ*2
286: jnz wrap3
287: mov bx,ADDR: kbbuf
288: wrap3: cmp bx,kbtail
289: mov ax,-1
290: jz endisin
291: mov ax,0
292: mov kbhead,bx
293: endisin: popf
294: pop bp
295: ret
296:
297: _kalloc: push bp
298: mov bp,sp
299: test byte ptr inload,0ffh
300: jz kalerr
301: mov cx,[bp+4]
302: mov ax,endbound
303: add ax,cx
304: jc kalerr
305: xchg ax,endbound
306: jmp short kalend
307: kalerr: mov ax,0
308: kalend: pop bp
309: ret
310: cohker endp
311:
312: ; null function, for irrelevant comands
313: badf proc near
314: les di,rhptr
315: mov es:[di+3],8103h ; unknown function for this device driver
316: nulf: ret
317: badf endp
318:
319: ; init function, set buffer, set interrupt vectors, set memory usage
320: init proc near
321: ; set up our own ds
322: mov ax,offset _TEXT: DGROUP
323: mov cl,4
324: shr ax,cl
325: mov bx,cs
326: add ax,bx
327: mov ds,ax
328: mov myds,ax
329:
330: ; zero .bss area
331: mov es,ax
332: xor ax,ax
333: mov cx,ADDR:databeg
334: mov di,ADDR:bssbeg
335: sub cx,di
336: shr cx,1
337: rep stosw
338:
339: ; get buffer size from config.sys line
340: ; size specified in 1024 byte blocks, consistent with ramdisk.dev
341: les di,rhptr
342: les di,es:[di+18] ; es:di = config.sys command line
343: push es
344: push di
345: call _dosline
346: add sp,4
347:
348: ; C initialization routine
349: call _sdload
350:
351: les si,rhptr
352: mov ax,endbound
353: mov es:[si+14],ax
354: mov es:[si+16],ds
355: mov inload,0
356:
357: ; set interrupt vectors
358: ; should be done using dos calls 25h and 35h,
359: ; but only calls 00h through 0ch and 30h are supported
360: ; during device driver init phase.
361: ; Disk Operating System Technical Reference Programming Manual
362: ; [IBM inc.] chapter 3.
363: ; Therefore, we disable interrupts,
364: ; and write the lowmem vectors directly
365: xor bx,bx
366: mov ds,bx
367: cli ; rest of init procedure has interrupts disabled
368: mov ax,[bx+20h] ; save original real time interrupt vector
369: mov orig_rti,ax
370: mov ax,[bx+22h]
371: mov orig_rti+2,ax
372: mov word ptr [bx+20h],offset _TEXT: ih_rti ; real time interrupt
373: mov [bx+22h],cs
374: mov ax,[bx+24h] ; save original keyboard interrupt vector
375: mov orig_kbi,ax
376: mov ax,[bx+26h]
377: mov orig_kbi+2,ax
378: mov word ptr [bx+24h], offset _TEXT: ih_kbi
379: mov [bx+26h],cs
380:
381: ; take over BIOS keyboard interrupt,
382: ; to accommodate our internal type ahead buffer (long).
383: mov ax,[bx+58h] ; save original bios keyboard interrupt vector
384: mov orig_bkb,ax
385: mov ax,[bx+5ah]
386: mov orig_bkb+2,ax
387: mov word ptr [bx+58h],offset _TEXT: ih_bkb ; BIOS keyboard interrupt
388: mov [bx+5ah],cs
389:
390: ; same for screen BIOS routine
391: mov ax,[bx+40h] ; save original bios screen interrupt vector
392: mov orig_bsc,ax
393: mov ax,[bx+42h]
394: mov orig_bsc+2,ax
395: mov word ptr [bx+40h],offset _TEXT: ih_bsc ; BIOS screen interrupt
396: mov [bx+42h],cs
397:
398: ; empty our own keyboard buffer
399: mov ds,myds
400: mov kbhead,ADDR: kbbuf
401: mov kbtail,ADDR: kbbuf
402: sti
403:
404: ; call original bios routine to clear any accumulated MS-DOS characters
405: drain: mov ah,1
406: pushf
407: ; call far ptr cs:[orig_bkb], I can't figure out the masm syntax for this
408: db 2eh, 0ffh, 01eh
409: dw orig_bkb
410: jz endinit
411: mov ah,0 ; remove character
412: pushf
413: ; call far ptr cs:[orig_bkb]
414: db 2eh, 0ffh, 01eh
415: dw orig_bkb
416: jmp short drain
417:
418: endinit: ret
419: init endp
420:
421: ; read ioctl values
422: ; used by a calling process to copy the text buffer to a file
423: ioctl proc near
424: ; returns pointers to the start and end of the internal text buffer
425: ; plus the head and tail pointers.
426: ; thus only 16-byte ioctl reads are allowed
427: ; calling process must understand this driver implicitly.
428: cmp cx,16
429: jnz badioctl
430: ; call C routine
431: push es
432: push di
433: mov ax, 0
434: push ax
435: call _sdioctl
436: add sp,6
437: or ax,ax
438: jz ioctlok
439: badioctl:
440: les di,rhptr
441: mov word ptr es:[di+18],0 ; 0 bytes transfered
442: mov es:[di+3],810bh ; read fault, cannot return that many bytes
443: ioctlok:
444: ret
445: ioctl endp
446:
447: ; screen BIOS routine
448: ; save characters written to screen, and pass all other commands through
449: ih_bsc proc far
450: cmp ah,14
451: jnz go10
452: cmp bx,7
453: jz scrchar
454:
455: ; jmp far ptr cs:[orig_bsc]
456: go10: db 2eh, 0ffh, 02eh
457: dw orig_bsc
458:
459: scrchar:
460: push ds
461: push ax
462: push bx
463: push cx
464: push dx
465: mov ds,myds
466: pushf
467: sti
468:
469: push ax
470: ; console is owner
471: mov ax,0
472: push ax
473: call _sdoutchar
474: add sp,4
475: popf
476:
477: test al,2
478: jz noesc
479: pop dx
480: pop cx
481: push cx
482: push dx
483: push ax
484: mov ax,0e1bh
485: mov bx,7
486: pushf
487: ; call far ptr cs:[orig_bsc]
488: db 2eh, 0ffh, 01eh
489: dw orig_bsc
490: pop ax
491: noesc: test al,1
492: pop dx
493: pop cx
494: pop bx
495: pop ax
496: pop ds
497: jz noscreen
498: jmp short go10
499:
500: noscreen: iret
501: ih_bsc endp
502:
503: ; interrupt routines
504:
505: ; read the virtual screen, in real time
506: ; called at real time interrupt level
507: ; Since this mess could easily take more than 50ms,
508: ; and I don't feel like counting instructions for all possible paths,
509: ; we call the original real time interrupt right away,
510: ; then we interpret keyboard commands, read text, etc.
511: ih_rti proc far ; user real time interrupt handler
512:
513: pushf ; call the original interrupt routine
514: ; call far ptr cs:[orig_rti]
515: db 2eh, 0ffh, 01eh
516: dw orig_rti
517:
518: ; simulate Coherent lbolt
519: push ds
520: mov ds,myds
521: add word ptr _lbolt,5
522: adc word ptr _lbolt+2,0
523: pop ds
524:
525: ; check for nested real time interrupts
526: dec nestrti
527: jz go_rti
528: inc nestrti
529: iret ; previous routine still reading, or whatever
530: go_rti:
531:
532: ; switch stacks
533: mov save_ss,ss
534: mov save_sp,sp
535: ; New stack overlays initialization code, about 200 bytes.
536: push cs
537: pop ss
538: mov sp,offset _TEXT: drain
539:
540: cld
541: push ds
542: push ax
543: push bx
544: push cx
545: push dx
546: push es
547:
548: mov ds,myds
549: sti
550:
551: call _sdtime
552:
553: cli
554: pop es
555: pop dx
556: pop cx
557: pop bx
558: pop ax
559: pop ds
560: mov ss,save_ss ; restore old stack
561: mov sp,save_sp
562: inc nestrti
563: iret
564: ih_rti endp
565:
566:
567: ih_com proc far
568: cld
569: push ds
570: push ax
571: push bx
572: push cx
573: push dx
574:
575: mov ds,myds
576: cld
577:
578: mov bx,ivec_fn
579: call bx
580:
581: mov al,eoi
582: out 20h,al
583: pop dx
584: pop cx
585: pop bx
586: pop ax
587: pop ds
588: iret
589: ih_com endp
590:
591:
592: ih_kbi proc far ; keyboard interrupt handler
593: pushf ; call the original hardware interrupt routine
594: ; call far ptr cs:[orig_kbi]
595: db 2eh, 0ffh, 01eh
596: dw orig_kbi
597: ; if a key was entered into the MS-DOS buffer,
598: ; and the key represents a reading command,
599: ; remove it from the buffer, and place the corresponding
600: ; command into the talkcmd location
601: ; we assume no real time (or other) interrupt routine will
602: ; grab the key from the buffer before this routine can snag it.
603: cld
604: push ax
605: push bx
606: push cx
607: push dx
608: push ds
609: ; C routines preserve si, di, and bp
610:
611: ; call original bios routine to get the entered character
612: mov ah,1
613: pushf
614: ; call far ptr cs:[orig_bkb]
615: db 2eh, 0ffh, 01eh
616: dw orig_bkb
617: jz nokey ; no new characters typed
618: ; now get the character
619: mov ah,0
620: pushf
621: ; call far ptr cs:[orig_bkb]
622: db 2eh, 0ffh, 01eh
623: dw orig_bkb
624:
625: mov ds,myds
626: push ax
627: cmp word ptr _sdcontrol,0
628: jz notactive
629: ; console is owner
630: mov ax,0
631: push ax
632: call _sdinkey ; turn key into command code
633: add sp,4
634: jmp short nokey
635: notactive:
636: call _isin
637: add sp,2
638:
639: nokey: pop ds
640: pop dx
641: pop cx
642: pop bx
643: pop ax
644: iret
645: ih_kbi endp
646:
647: ; new BIOS keyboarde routine, to accommodate new type ahead buffer.
648: ;
649: ; the original bios routine enables interrupts,
650: ; and when ah = 1, leaves them that way,
651: ; regardless of the initial conditions.
652: ; don't know if this is a feature or a bug, but I emulate it.
653: ;
654: ; For some bizarre reason, dos4.0 calls this BIOS routine
655: ; with ah = 10h, 11h, or 12h, instead of 0, 1, or 2.
656: ; I have no idea what the extra bit means.
657: ; I simply clear it out, and things seem to work.
658: ; Thus this bios routine works under all versions of dos,
659: ; as of this writing.
660: ih_bkb proc far
661: sti
662: and ah,0efh
663: cmp ah,1
664: jb getc
665: jz nbget
666: ; jmp far ptr cs:[orig_bkb]
667: db 2eh, 0ffh, 02eh
668: dw orig_bkb
669:
670: nbget: ; non blocking getchar
671: push ds
672: push bx
673: mov ds,myds
674: mov bx,kbtail
675: cmp bx,kbhead
676: mov ax,[bx]
677: pop bx
678: pop ds
679: ret 2
680:
681: getc: ; blocking getchar
682: push ds
683: push bx
684: mov ds,myds
685: mov bx,kbtail
686: cmp bx,kbhead
687: mov ax,[bx]
688: jz getc
689: inc bx
690: inc bx
691: cmp bx,ADDR: kbbuf+KBSIZ*2
692: jnz wrap6
693: mov bx,ADDR: kbbuf
694: wrap6: mov kbtail,bx
695: pop bx
696: pop ds
697: iret
698: ih_bkb endp
699:
700: _TEXT ends
701:
702:
703: _BSS segment
704: bssbeg dw ?
705: _BSS ends
706:
707:
708: _DATA segment
709:
710: extrn _lbolt:word, _sdcontrol:word
711:
712: databeg label word
713:
714: ; we implement our own interrupt level keyboard buffer
715: ; the ms-dos buffer (15 characters) is frustratingly small
716: kbbuf dw KBSIZ dup(?)
717: kbhead dw kbbuf
718: kbtail dw kbbuf
719:
720: ivec_fn dw 0 ; setivec function
721:
722: endbound dw ADDR: boundary
723: inload db 1 ; are we in load phase?
724:
725: intofs dw 30h ; offset for interrupt vector
726: irm db 0efh ; interrupt register mask
727: eoi db 64h ; end of interrupt code
728:
729: _DATA ends
730:
731:
732: ; to find the end of DGROUP, and the start of word table and buffer
733: _EDATA segment
734: boundary label word
735: _EDATA ends
736:
737: end HDR
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.