URL https://opencores.org/ocsvn/thor/thor/trunk

Subversion Repositories thor

[/] [thor/] [trunk/] [software/] [FMTK/] [source/] [kernel/] [keybd.c] - Blame information for rev 23

Details | Compare with Previous | View Log


// The keyboard semaphore is locked only for short durations, so the interrupt
// routine doesn't need to make many attempts to lock the semaphore.
 
#include "config.h"
#include "const.h"
#include "types.h"
#include "glo.h"
#include "proto.h"
 
#define SC_F12      0x07
#define SC_C        0x21
#define SC_T        0x2C
#define SC_Z        0x1A
#define SC_KEYUP        0xF0
#define SC_EXTEND   0xE0
#define SC_CTRL         0x14
#define SC_RSHIFT       0x59
#define SC_NUMLOCK      0x77
#define SC_SCROLLLOCK   0x7E
#define SC_CAPSLOCK     0x58
#define SC_ALT          0x11
/*
#define SC_LSHIFT       EQU             $12
SC_DEL          EQU             $71             ; extend
SC_LCTRL        EQU             $58
*/
#define SC_TAB      0x0D
 
extern byte keybdExtendedCodes[];
extern byte keybdControlCodes[];
extern byte shiftedScanCodes[];
extern byte unshiftedScanCodes[];
extern signed byte KeybdGetStatus();
extern byte KeybdGetScancode();
extern void KeybdClearRcv();
int kbd_sema = 0;
 
//
// KeyState2_
// 76543210
// |||||||+ = shift
// ||||||+- = alt
// |||||+-- = control
// ||||+--- = numlock
// |||+---- = capslock
// ||+----- = scrolllock
// |+------ =
// +------- = extended
//
 
unsigned int keybd_irq_stack[256];
static hMBX hKeybdMbx = -1;
 
void KeybdIRQ()
{
    __int8 sc;
    __int8 kh, kt;
    hTCB ht;
    TCB *t;
    JCB *jcb;
    int nn;
 
        prolog asm {
                sync
                sw              r1,TCB_ir1[tr]
                sw              r2,TCB_ir2[tr]
                sw              r3,TCB_ir3[tr]
                sw              r4,TCB_ir4[tr]
                sw              r5,TCB_ir5[tr]
                sw              r6,TCB_ir6[tr]
                sw              r7,TCB_ir7[tr]
                sw              r8,TCB_ir8[tr]
                sw              r9,TCB_ir9[tr]
                sw              r10,TCB_ir10[tr]
                sw              r11,TCB_ir11[tr]
                sw              r12,TCB_ir12[tr]
                sw              r13,TCB_ir13[tr]
                sw              r14,TCB_ir14[tr]
                sw              r15,TCB_ir15[tr]
                sw              r16,TCB_ir16[tr]
                sw              r17,TCB_ir17[tr]
                sw              r18,TCB_ir18[tr]
                sw              r19,TCB_ir19[tr]
                sw              r20,TCB_ir20[tr]
                sw              r21,TCB_ir21[tr]
                sw              r22,TCB_ir22[tr]
                sw              r23,TCB_ir23[tr]
                sw              r24,TCB_ir24[tr]
                sw              r25,TCB_ir25[tr]
                sw              r26,TCB_ir26[tr]
                sw              r27,TCB_ir27[tr]
                sws             ds,TCB_ids[tr]
                sws             es,TCB_ies[tr]
                sws             fs,TCB_ifs[tr]
                sws             gs,TCB_igs[tr]
                sws             hs,TCB_ihs[tr]
                sws             ss,TCB_iss[tr]
                sws             cs,TCB_ics[tr]
                sws             ds.lmt,TCB_idslmt[tr]
                sws             es.lmt,TCB_ieslmt[tr]
                sws             fs.lmt,TCB_ifslmt[tr]
                sws             gs.lmt,TCB_igslmt[tr]
                sws             hs.lmt,TCB_ihslmt[tr]
                sws             ss.lmt,TCB_isslmt[tr]
                sws             cs.lmt,TCB_icslmt[tr]
                sws             c1,TCB_ic1[tr]
                sws             c2,TCB_ic2[tr]
                sws             c3,TCB_ic3[tr]
                sws             c4,TCB_ic4[tr]
                sws             c5,TCB_ic5[tr]
                sws             c6,TCB_ic6[tr]
                sws             c7,TCB_ic7[tr]
                sws             c8,TCB_ic8[tr]
                sws             c9,TCB_ic9[tr]
                sws             c10,TCB_ic10[tr]
                sws             c11,TCB_ic11[tr]
                sws             c13,TCB_ic13[tr]
                sws             c14,TCB_ic14[tr]
                sws             pregs,TCB_ipregs[tr]
 
                ldi             sp,#irq_stack_+511*8    ; setup system stack and data segments
                mtspr   ss,r0
                ldis    ss.lmt,#-1
                mtspr   ds,r0
                ldis    ds.lmt,#-1
                ldi             hs,#$FFD00000
                ldi             hs.lmt,#$100000
        }
     while (KeybdGetStatus() < 0) {    // Is there actually a scancode available ?
         sc = KeybdGetScancode();
         jcb = IOFocusNdx;             // Are there any jobs with focus ?     
         if (jcb) {
                 if (LockSemaphore(&kbd_sema,200)) {
                 KeybdClearRcv();              // clear recieve register
                 kh = jcb->KeybdHead;
                 kt = jcb->KeybdTail;
                 kh++;
                                 if (kh > jcb->KeybdBufSz)
                                         kh = 0;
                 if (kh <> kt) {
                     jcb->KeybdHead = kh;
                     jcb->KeybdBuf[kh] = sc;
                 }
                 UnlockSemaphore(&kbd_sema);
             }
             // Trigger debugger if F12 pressed. Set a breakpoint at the RTI
             // return address.
             if (sc==SC_F12 && !jcb->KeyState1) {
                 asm {
                     mfspr  r1,ipc
                     mtspr  dbad0,r1      ; Set breakpoint 0 address
                     mfspr  r1,dbctrl
                     or     r1,r1,#1      ; enable breakpoint #0
                     and    r1,r1,#~0x30000
                     mtspr  dbctrl,r1
                 }
             }
             // If CTRL-C is pressed, cause the tasks to return to the 
             // catch handler.
             if (jcb->KeyState2 & 4) {
                 if(sc == SC_C) {      // control-c ?
                     for (nn = 0; nn < 8; nn++) {
                         if (jcb->tasks[nn]==-1)
                             break;
                         t = &tcbs[jcb->tasks[nn]];
                         t->exception = 512+3;     // CTRL-C type exception
                     }
                 }
                 else if (sc==SC_T || sc==SC_Z) {
                      t = &tcbs[2];
                      t->exception = (512 + ((sc==SC_T) ? 20 : 26)) | (GetRunningTCB() << 32);
                 }
             }
             if ((jcb->KeyState2 & 2) && sc == SC_TAB)    // ALT + TAB ?
                 if (hFocusSwitchMbx >= 0)
                     FMTK_PostMsg(hFocusSwitchMbx,-1,-1,-1);
//                 iof_switch++;
         }
         if (hKeybdMbx >= 0)
            FMTK_PostMsg(hKeybdMbx,-1,-1,-1);
     }
     // Restore the processor registers and return using an RTI.
        epilog asm {
                lw              r1,TCB_ir1[tr]
                lw              r2,TCB_ir2[tr]
                lw              r3,TCB_ir3[tr]
                lw              r4,TCB_ir4[tr]
                lw              r5,TCB_ir5[tr]
                lw              r6,TCB_ir6[tr]
                lw              r7,TCB_ir7[tr]
                lw              r8,TCB_ir8[tr]
                lw              r9,TCB_ir9[tr]
                lw              r10,TCB_ir10[tr]
                lw              r11,TCB_ir11[tr]
                lw              r12,TCB_ir12[tr]
                lw              r13,TCB_ir13[tr]
                lw              r14,TCB_ir14[tr]
                lw              r15,TCB_ir15[tr]
                lw              r16,TCB_ir16[tr]
                lw              r17,TCB_ir17[tr]
                lw              r18,TCB_ir18[tr]
                lw              r19,TCB_ir19[tr]
                lw              r20,TCB_ir20[tr]
                lw              r21,TCB_ir21[tr]
                lw              r22,TCB_ir22[tr]
                lw              r23,TCB_ir23[tr]
                lw              r24,TCB_ir24[tr]
                lw              r25,TCB_ir25[tr]
                lw              r26,TCB_ir26[tr]
                lw              r27,TCB_ir27[tr]
                lws             ds,TCB_ids[tr]
                lws             es,TCB_ies[tr]
                lws             fs,TCB_ifs[tr]
                lws             gs,TCB_igs[tr]
                lws             hs,TCB_ihs[tr]
                lws             ss,TCB_iss[tr]
                lws             cs,TCB_ics[tr]
                lws             ds.lmt,TCB_idslmt[tr]
                lws             es.lmt,TCB_ieslmt[tr]
                lws             fs.lmt,TCB_ifslmt[tr]
                lws             gs.lmt,TCB_igslmt[tr]
                lws             hs.lmt,TCB_ihslmt[tr]
                lws             ss.lmt,TCB_isslmt[tr]
                lws             cs.lmt,TCB_icslmt[tr]
                lws             c1,TCB_ic1[tr]
                lws             c2,TCB_ic2[tr]
                lws             c3,TCB_ic3[tr]
                lws             c4,TCB_ic4[tr]
                lws             c5,TCB_ic5[tr]
                lws             c6,TCB_ic6[tr]
                lws             c7,TCB_ic7[tr]
                lws             c8,TCB_ic8[tr]
                lws             c9,TCB_ic9[tr]
                lws             c10,TCB_ic10[tr]
                lws             c11,TCB_ic11[tr]
                lws             c13,TCB_ic13[tr]
                lws             c14,TCB_ic14[tr]
                lws             pregs,TCB_ipregs[tr]
                sync
                rti
        }
}
 
 
// Return -1 if there is a scancode available in the buffer.
 
int KeybdGetBufferStatus()
{
    JCB *j;
    __int8 kh, kt;
 
    kh = kt = 0;
    j = GetJCBPtr();
    if (LockSemaphore(&kbd_sema,200)) {
        kh = j->KeybdHead;
        kt = j->KeybdTail;
        UnlockSemaphore(&kbd_sema);
    }
    if (kh<>kt)
        return -1;
    return 0;
 
}
 
// Get a scancode from the keyboard buffer.
 
__int8 KeybdGetBufferedScancode()
{
    JCB *j;
    __int8 kh, kt;
    __int8 sc;
 
    j = GetJCBPtr();
    sc = 0;
    if (LockSemaphore(&kbd_sema,200)) {
        kh = j->KeybdHead;
        kt = j->KeybdTail;
        if (kh <> kt) {
            sc = j->KeybdBuf[kt];
            kt++;
                        if (kt > j->KeybdBufSz)
                                kt = 0;
            j->KeybdTail = kt;
        }
        UnlockSemaphore(&kbd_sema);
    }
    return sc;
}
 
private char KeybdGetBufferedChar()
{
    JCB *j;
    unsigned __int8 sc;
    char ch;
    int d1, d2, d3;
        static int fc = 0;
 
    if (!fc) {
        FMTK_AllocMbx(&hKeybdMbx);
                fc = 1;
    }
    j = GetJCBPtr();
    forever {
        while (KeybdGetBufferStatus() >= 0) {
            if (j->KeybdWaitFlag==0)
                return -1;
            FMTK_WaitMsg(hKeybdMbx, &d1, &d2, &d3, 0x7FFFFFFFFFFFFFFFL);
        }
        // The following typecast is needed to avoid a compiler bug in the
        // optimizer which removes the conversion from byte to word by zero
        // extension.
        sc = (unsigned __int8)KeybdGetBufferedScancode();
        switch(sc) {
        case SC_KEYUP:
            j->KeyState1 = -1;
            break;
        case SC_EXTEND:
            j->KeyState2 |= 0x80;
            break;
        case SC_CTRL:
            if (j->KeyState1 >= 0)
                j->KeyState2 |= 4;
            else
                j->KeyState2 &= ~4;
            j->KeyState1 = 0;
            break;
        case SC_RSHIFT:
            if (j->KeyState1 >= 0)
                j->KeyState2 |= 1;
            else
                j->KeyState2 &= ~1;
            j->KeyState1 = 0;
            break;
        case SC_NUMLOCK:
            j->KeyState2 ^= 16;
            //KeybdSetLEDStatus();
            break;
        case SC_CAPSLOCK:
            j->KeyState2 ^= 32;
            //KeybdSetLEDStatus();
            break;
        case SC_SCROLLLOCK:
            j->KeyState2 ^= 64;
            //KeybdSetLEDStatus();
            break;
        case SC_ALT:
            if (j->KeyState1 >= 0)
                j->KeyState2 |= 2;
            else
                j->KeyState2 &= ~2;
            j->KeyState1 = 0;
            break;
        default:
            if (sc == SC_TAB && (j->KeyState2 & 2) && j->KeyState1==0) {
                iof_switch++;
            }
            else {
                 if (j->KeyState1) {
                     j->KeyState1 = 0;
                 }
                 else {
                      if (j->KeyState2 & 0x80) { // Extended code ?
                          j->KeyState2 &= ~0x80;
                          ch = keybdExtendedCodes[sc];
                          return ch;
                      }
                      else if (j->KeyState2 & 0x04) { // control ?
                          ch = keybdControlCodes[sc];
                          return ch;
                      }
                      else if (j->KeyState2 & 0x01) { // shifted ?
                          ch = shiftedScanCodes[sc];
                          return ch;
                      }
                      else {
                          ch = unshiftedScanCodes[sc];
                          return ch;
                      }
                 }
            }
        }
    }
}
 
char KeybdGetBufferedCharWait() {
    JCB *j;
    j = GetJCBPtr();
    j->KeybdWaitFlag = 1;
    return KeybdGetBufferedChar();
}
 
char KeybdGetBufferedCharNoWait() {
    JCB *j;
    j = GetJCBPtr();
    j->KeybdWaitFlag = 0;
    return KeybdGetBufferedChar();
}
 

Browse

Tools

Subversion Repositories thor

[/] [thor/] [trunk/] [software/] [FMTK/] [source/] [kernel/] [keybd.c] - Blame information for rev 23

Line No.	Rev	Author	Line
1	23	robfinch	`// The keyboard semaphore is locked only for short durations, so the interrupt`
2			`// routine doesn't need to make many attempts to lock the semaphore.`
3
4			`#include "config.h"`
5			`#include "const.h"`
6			`#include "types.h"`
7			`#include "glo.h"`
8			`#include "proto.h"`
9
10			`#define SC_F12 0x07`
11			`#define SC_C 0x21`
12			`#define SC_T 0x2C`
13			`#define SC_Z 0x1A`
14			`#define SC_KEYUP 0xF0`
15			`#define SC_EXTEND 0xE0`
16			`#define SC_CTRL 0x14`
17			`#define SC_RSHIFT 0x59`
18			`#define SC_NUMLOCK 0x77`
19			`#define SC_SCROLLLOCK 0x7E`
20			`#define SC_CAPSLOCK 0x58`
21			`#define SC_ALT 0x11`
22			`/*`
23			`#define SC_LSHIFT EQU $12`
24			`SC_DEL EQU $71 ; extend`
25			`SC_LCTRL EQU $58`
26			`*/`
27			`#define SC_TAB 0x0D`
28
29			`extern byte keybdExtendedCodes[];`
30			`extern byte keybdControlCodes[];`
31			`extern byte shiftedScanCodes[];`
32			`extern byte unshiftedScanCodes[];`
33			`extern signed byte KeybdGetStatus();`
34			`extern byte KeybdGetScancode();`
35			`extern void KeybdClearRcv();`
36			`int kbd_sema = 0;`
37
38			`//`
39			`// KeyState2_`
40			`// 76543210`
41			`// \|\|\|\|\|\|\|+ = shift`
42			`// \|\|\|\|\|\|+- = alt`
43			`// \|\|\|\|\|+-- = control`
44			`// \|\|\|\|+--- = numlock`
45			`// \|\|\|+---- = capslock`
46			`// \|\|+----- = scrolllock`
47			`// \|+------ =`
48			`// +------- = extended`
49			`//`
50
51			`unsigned int keybd_irq_stack[256];`
52			`static hMBX hKeybdMbx = -1;`
53
54			`void KeybdIRQ()`
55			`{`
56			`__int8 sc;`
57			`__int8 kh, kt;`
58			`hTCB ht;`
59			`TCB *t;`
60			`JCB *jcb;`
61			`int nn;`
62
63			`prolog asm {`
64			`sync`
65			`sw r1,TCB_ir1[tr]`
66			`sw r2,TCB_ir2[tr]`
67			`sw r3,TCB_ir3[tr]`
68			`sw r4,TCB_ir4[tr]`
69			`sw r5,TCB_ir5[tr]`
70			`sw r6,TCB_ir6[tr]`
71			`sw r7,TCB_ir7[tr]`
72			`sw r8,TCB_ir8[tr]`
73			`sw r9,TCB_ir9[tr]`
74			`sw r10,TCB_ir10[tr]`
75			`sw r11,TCB_ir11[tr]`
76			`sw r12,TCB_ir12[tr]`
77			`sw r13,TCB_ir13[tr]`
78			`sw r14,TCB_ir14[tr]`
79			`sw r15,TCB_ir15[tr]`
80			`sw r16,TCB_ir16[tr]`
81			`sw r17,TCB_ir17[tr]`
82			`sw r18,TCB_ir18[tr]`
83			`sw r19,TCB_ir19[tr]`
84			`sw r20,TCB_ir20[tr]`
85			`sw r21,TCB_ir21[tr]`
86			`sw r22,TCB_ir22[tr]`
87			`sw r23,TCB_ir23[tr]`
88			`sw r24,TCB_ir24[tr]`
89			`sw r25,TCB_ir25[tr]`
90			`sw r26,TCB_ir26[tr]`
91			`sw r27,TCB_ir27[tr]`
92			`sws ds,TCB_ids[tr]`
93			`sws es,TCB_ies[tr]`
94			`sws fs,TCB_ifs[tr]`
95			`sws gs,TCB_igs[tr]`
96			`sws hs,TCB_ihs[tr]`
97			`sws ss,TCB_iss[tr]`
98			`sws cs,TCB_ics[tr]`
99			`sws ds.lmt,TCB_idslmt[tr]`
100			`sws es.lmt,TCB_ieslmt[tr]`
101			`sws fs.lmt,TCB_ifslmt[tr]`
102			`sws gs.lmt,TCB_igslmt[tr]`
103			`sws hs.lmt,TCB_ihslmt[tr]`
104			`sws ss.lmt,TCB_isslmt[tr]`
105			`sws cs.lmt,TCB_icslmt[tr]`
106			`sws c1,TCB_ic1[tr]`
107			`sws c2,TCB_ic2[tr]`
108			`sws c3,TCB_ic3[tr]`
109			`sws c4,TCB_ic4[tr]`
110			`sws c5,TCB_ic5[tr]`
111			`sws c6,TCB_ic6[tr]`
112			`sws c7,TCB_ic7[tr]`
113			`sws c8,TCB_ic8[tr]`
114			`sws c9,TCB_ic9[tr]`
115			`sws c10,TCB_ic10[tr]`
116			`sws c11,TCB_ic11[tr]`
117			`sws c13,TCB_ic13[tr]`
118			`sws c14,TCB_ic14[tr]`
119			`sws pregs,TCB_ipregs[tr]`
120
121			`ldi sp,#irq_stack_+511*8 ; setup system stack and data segments`
122			`mtspr ss,r0`
123			`ldis ss.lmt,#-1`
124			`mtspr ds,r0`
125			`ldis ds.lmt,#-1`
126			`ldi hs,#$FFD00000`
127			`ldi hs.lmt,#$100000`
128			`}`
129			`while (KeybdGetStatus() < 0) { // Is there actually a scancode available ?`
130			`sc = KeybdGetScancode();`
131			`jcb = IOFocusNdx; // Are there any jobs with focus ?`
132			`if (jcb) {`
133			`if (LockSemaphore(&kbd_sema,200)) {`
134			`KeybdClearRcv(); // clear recieve register`
135			`kh = jcb->KeybdHead;`
136			`kt = jcb->KeybdTail;`
137			`kh++;`
138			`if (kh > jcb->KeybdBufSz)`
139			`kh = 0;`
140			`if (kh <> kt) {`
141			`jcb->KeybdHead = kh;`
142			`jcb->KeybdBuf[kh] = sc;`
143			`}`
144			`UnlockSemaphore(&kbd_sema);`
145			`}`
146			`// Trigger debugger if F12 pressed. Set a breakpoint at the RTI`
147			`// return address.`
148			`if (sc==SC_F12 && !jcb->KeyState1) {`
149			`asm {`
150			`mfspr r1,ipc`
151			`mtspr dbad0,r1 ; Set breakpoint 0 address`
152			`mfspr r1,dbctrl`
153			`or r1,r1,#1 ; enable breakpoint #0`
154			`and r1,r1,#~0x30000`
155			`mtspr dbctrl,r1`
156			`}`
157			`}`
158			`// If CTRL-C is pressed, cause the tasks to return to the`
159			`// catch handler.`
160			`if (jcb->KeyState2 & 4) {`
161			`if(sc == SC_C) { // control-c ?`
162			`for (nn = 0; nn < 8; nn++) {`
163			`if (jcb->tasks[nn]==-1)`
164			`break;`
165			`t = &tcbs[jcb->tasks[nn]];`
166			`t->exception = 512+3; // CTRL-C type exception`
167			`}`
168			`}`
169			`else if (sc==SC_T \|\| sc==SC_Z) {`
170			`t = &tcbs[2];`
171			`t->exception = (512 + ((sc==SC_T) ? 20 : 26)) \| (GetRunningTCB() << 32);`
172			`}`
173			`}`
174			`if ((jcb->KeyState2 & 2) && sc == SC_TAB) // ALT + TAB ?`
175			`if (hFocusSwitchMbx >= 0)`
176			`FMTK_PostMsg(hFocusSwitchMbx,-1,-1,-1);`
177			`// iof_switch++;`
178			`}`
179			`if (hKeybdMbx >= 0)`
180			`FMTK_PostMsg(hKeybdMbx,-1,-1,-1);`
181			`}`
182			`// Restore the processor registers and return using an RTI.`
183			`epilog asm {`
184			`lw r1,TCB_ir1[tr]`
185			`lw r2,TCB_ir2[tr]`
186			`lw r3,TCB_ir3[tr]`
187			`lw r4,TCB_ir4[tr]`
188			`lw r5,TCB_ir5[tr]`
189			`lw r6,TCB_ir6[tr]`
190			`lw r7,TCB_ir7[tr]`
191			`lw r8,TCB_ir8[tr]`
192			`lw r9,TCB_ir9[tr]`
193			`lw r10,TCB_ir10[tr]`
194			`lw r11,TCB_ir11[tr]`
195			`lw r12,TCB_ir12[tr]`
196			`lw r13,TCB_ir13[tr]`
197			`lw r14,TCB_ir14[tr]`
198			`lw r15,TCB_ir15[tr]`
199			`lw r16,TCB_ir16[tr]`
200			`lw r17,TCB_ir17[tr]`
201			`lw r18,TCB_ir18[tr]`
202			`lw r19,TCB_ir19[tr]`
203			`lw r20,TCB_ir20[tr]`
204			`lw r21,TCB_ir21[tr]`
205			`lw r22,TCB_ir22[tr]`
206			`lw r23,TCB_ir23[tr]`
207			`lw r24,TCB_ir24[tr]`
208			`lw r25,TCB_ir25[tr]`
209			`lw r26,TCB_ir26[tr]`
210			`lw r27,TCB_ir27[tr]`
211			`lws ds,TCB_ids[tr]`
212			`lws es,TCB_ies[tr]`
213			`lws fs,TCB_ifs[tr]`
214			`lws gs,TCB_igs[tr]`
215			`lws hs,TCB_ihs[tr]`
216			`lws ss,TCB_iss[tr]`
217			`lws cs,TCB_ics[tr]`
218			`lws ds.lmt,TCB_idslmt[tr]`
219			`lws es.lmt,TCB_ieslmt[tr]`
220			`lws fs.lmt,TCB_ifslmt[tr]`
221			`lws gs.lmt,TCB_igslmt[tr]`
222			`lws hs.lmt,TCB_ihslmt[tr]`
223			`lws ss.lmt,TCB_isslmt[tr]`
224			`lws cs.lmt,TCB_icslmt[tr]`
225			`lws c1,TCB_ic1[tr]`
226			`lws c2,TCB_ic2[tr]`
227			`lws c3,TCB_ic3[tr]`
228			`lws c4,TCB_ic4[tr]`
229			`lws c5,TCB_ic5[tr]`
230			`lws c6,TCB_ic6[tr]`
231			`lws c7,TCB_ic7[tr]`
232			`lws c8,TCB_ic8[tr]`
233			`lws c9,TCB_ic9[tr]`
234			`lws c10,TCB_ic10[tr]`
235			`lws c11,TCB_ic11[tr]`
236			`lws c13,TCB_ic13[tr]`
237			`lws c14,TCB_ic14[tr]`
238			`lws pregs,TCB_ipregs[tr]`
239			`sync`
240			`rti`
241			`}`
242			`}`
243
244
245			`// Return -1 if there is a scancode available in the buffer.`
246
247			`int KeybdGetBufferStatus()`
248			`{`
249			`JCB *j;`
250			`__int8 kh, kt;`
251
252			`kh = kt = 0;`
253			`j = GetJCBPtr();`
254			`if (LockSemaphore(&kbd_sema,200)) {`
255			`kh = j->KeybdHead;`
256			`kt = j->KeybdTail;`
257			`UnlockSemaphore(&kbd_sema);`
258			`}`
259			`if (kh<>kt)`
260			`return -1;`
261			`return 0;`
262
263			`}`
264
265			`// Get a scancode from the keyboard buffer.`
266
267			`__int8 KeybdGetBufferedScancode()`
268			`{`
269			`JCB *j;`
270			`__int8 kh, kt;`
271			`__int8 sc;`
272
273			`j = GetJCBPtr();`
274			`sc = 0;`
275			`if (LockSemaphore(&kbd_sema,200)) {`
276			`kh = j->KeybdHead;`
277			`kt = j->KeybdTail;`
278			`if (kh <> kt) {`
279			`sc = j->KeybdBuf[kt];`
280			`kt++;`
281			`if (kt > j->KeybdBufSz)`
282			`kt = 0;`
283			`j->KeybdTail = kt;`
284			`}`
285			`UnlockSemaphore(&kbd_sema);`
286			`}`
287			`return sc;`
288			`}`
289
290			`private char KeybdGetBufferedChar()`
291			`{`
292			`JCB *j;`
293			`unsigned __int8 sc;`
294			`char ch;`
295			`int d1, d2, d3;`
296			`static int fc = 0;`
297
298			`if (!fc) {`
299			`FMTK_AllocMbx(&hKeybdMbx);`
300			`fc = 1;`
301			`}`
302			`j = GetJCBPtr();`
303			`forever {`
304			`while (KeybdGetBufferStatus() >= 0) {`
305			`if (j->KeybdWaitFlag==0)`
306			`return -1;`
307			`FMTK_WaitMsg(hKeybdMbx, &d1, &d2, &d3, 0x7FFFFFFFFFFFFFFFL);`
308			`}`
309			`// The following typecast is needed to avoid a compiler bug in the`
310			`// optimizer which removes the conversion from byte to word by zero`
311			`// extension.`
312			`sc = (unsigned __int8)KeybdGetBufferedScancode();`
313			`switch(sc) {`
314			`case SC_KEYUP:`
315			`j->KeyState1 = -1;`
316			`break;`
317			`case SC_EXTEND:`
318			`j->KeyState2 \|= 0x80;`
319			`break;`
320			`case SC_CTRL:`
321			`if (j->KeyState1 >= 0)`
322			`j->KeyState2 \|= 4;`
323			`else`
324			`j->KeyState2 &= ~4;`
325			`j->KeyState1 = 0;`
326			`break;`
327			`case SC_RSHIFT:`
328			`if (j->KeyState1 >= 0)`
329			`j->KeyState2 \|= 1;`
330			`else`
331			`j->KeyState2 &= ~1;`
332			`j->KeyState1 = 0;`
333			`break;`
334			`case SC_NUMLOCK:`
335			`j->KeyState2 ^= 16;`
336			`//KeybdSetLEDStatus();`
337			`break;`
338			`case SC_CAPSLOCK:`
339			`j->KeyState2 ^= 32;`
340			`//KeybdSetLEDStatus();`
341			`break;`
342			`case SC_SCROLLLOCK:`
343			`j->KeyState2 ^= 64;`
344			`//KeybdSetLEDStatus();`
345			`break;`
346			`case SC_ALT:`
347			`if (j->KeyState1 >= 0)`
348			`j->KeyState2 \|= 2;`
349			`else`
350			`j->KeyState2 &= ~2;`
351			`j->KeyState1 = 0;`
352			`break;`
353			`default:`
354			`if (sc == SC_TAB && (j->KeyState2 & 2) && j->KeyState1==0) {`
355			`iof_switch++;`
356			`}`
357			`else {`
358			`if (j->KeyState1) {`
359			`j->KeyState1 = 0;`
360			`}`
361			`else {`
362			`if (j->KeyState2 & 0x80) { // Extended code ?`
363			`j->KeyState2 &= ~0x80;`
364			`ch = keybdExtendedCodes[sc];`
365			`return ch;`
366			`}`
367			`else if (j->KeyState2 & 0x04) { // control ?`
368			`ch = keybdControlCodes[sc];`
369			`return ch;`
370			`}`
371			`else if (j->KeyState2 & 0x01) { // shifted ?`
372			`ch = shiftedScanCodes[sc];`
373			`return ch;`
374			`}`
375			`else {`
376			`ch = unshiftedScanCodes[sc];`
377			`return ch;`
378			`}`
379			`}`
380			`}`
381			`}`
382			`}`
383			`}`
384
385			`char KeybdGetBufferedCharWait() {`
386			`JCB *j;`
387			`j = GetJCBPtr();`
388			`j->KeybdWaitFlag = 1;`
389			`return KeybdGetBufferedChar();`
390			`}`
391
392			`char KeybdGetBufferedCharNoWait() {`
393			`JCB *j;`
394			`j = GetJCBPtr();`
395			`j->KeybdWaitFlag = 0;`
396			`return KeybdGetBufferedChar();`
397			`}`
398