![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to kbdld.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / sys / sundev|
Return to kbdld.c CVS log | Up to [Research Unix] / researchv9 / sys / sundev |
1.1 root 1: /*
2: * Copyright (C) 1985 by Sun Microsystems, Inc.
3: */
4: #include "kbd.h"
5: #if NKBD > 0
6: /*
7: * Keyboard input line discipline.
8: * Console output line discipline.
9: */
10: #include "../h/param.h"
11: #include "../h/systm.h"
12: #include "../h/stream.h"
13: #include "../h/ttyio.h"
14: #include "../h/ttyld.h"
15: #include "../h/conf.h"
16: #include "../machine/sunromvec.h"
17: #include "../sundev/kbdvar.h"
18:
19: /*
20: * For now these are shared.
21: */
22: extern int nkeytables;
23: extern struct keyboard *keytables[];
24: extern char keystringtab[16][KTAB_STRLEN];
25:
26: #define TIMEOUT 04
27:
28: struct kbdld {
29: /* Added for 9th edition */
30: struct queue *key_q; /* queue for the keyboard */
31: struct queue *cons_q; /* queue for output to the console */
32: short c_state; /* state of the console */
33: /* Defined by sun */
34: u_char k_id;
35: u_char k_idstate;
36: u_char k_state;
37: u_char k_rptkey;
38: u_int k_buckybits;
39: u_int k_shiftmask;
40: struct keyboard *k_curkeyboard;
41: u_int k_togglemask; /* Toggle shifts state */
42: } kbd[NKBD], nullkbd;
43:
44: /*
45: * States of keyboard ID recognizer
46: */
47: #define KID_NONE 0 /* startup */
48: #define KID_IDLE 1 /* saw IDLE code */
49: #define KID_LKSUN2 2 /* probably Sun-2 */
50: #define KID_OK 3 /* locked on ID */
51:
52: /*
53: * Constants setup during the first open of a kbd (so that hz is defined).
54: */
55: int kbd_repeatrate;
56: int kbd_repeatdelay;
57:
58: int kbdopen(), kbdclose(), kbdldin(), kbdisrv(), kbdldout();
59: static struct qinit kbdrinit = { kbdldin, kbdisrv, kbdopen, kbdclose,300, 60};
60: static struct qinit kbdwinit = { kbdldout, NULL, kbdopen, kbdclose, 200, 100 };
61: struct streamtab kbdinfo = { &kbdrinit, &kbdwinit};
62:
63: /*
64: * Keyboard and console open
65: */
66: kbdopen(qp, dev)
67: register struct queue *qp;
68: {
69: register struct kbdld *k;
70:
71: /* Set these up only once so that they could be changed from adb */
72: if (!kbd_repeatrate) {
73: kbd_repeatrate = (hz+29)/30;
74: kbd_repeatdelay = hz/2;
75: }
76: if (qp->ptr) /* already attached */
77: return(1);
78: for (k = kbd; k->key_q != 0; k++)
79: if (k >= &kbd[NKBD])
80: return(0);
81: *k = nullkbd;
82: k->key_q = qp;
83: k->cons_q = WR(qp);
84: qp->ptr = (caddr_t)k;
85: WR(qp)->ptr = (caddr_t)k;
86: kbdreset(k);
87: return(1);
88: }
89:
90: kbdclose(qp)
91: register struct queue *qp;
92: {
93: register struct kbdld *k = (struct kbdld *)qp->ptr;
94:
95: k->key_q = 0;
96: k->cons_q = 0;
97: }
98:
99: /*
100: * Console write put routine
101: */
102: kbdldout(q, bp)
103: register struct queue *q;
104: register struct block *bp;
105: {
106: register union stmsg *sp;
107: register struct kbdld *k = (struct kbdld *)q->ptr;
108:
109: switch(bp->type) {
110:
111: case M_IOCTL:
112: sp = (union stmsg *)bp->rptr;
113: switch (sp->ioc0.com) {
114:
115: case TIOCGDEV:
116: sp->ioc3.sb.ispeed =
117: sp->ioc3.sb.ospeed = B9600;
118: bp->type = M_IOCACK;
119: qreply(q, bp);
120: return;
121: case TIOCSDEV:
122: bp->wptr = bp->rptr;
123: bp->type = M_IOCACK;
124: qreply(q, bp);
125: return;
126: default:
127: bp->type = M_IOCNAK;
128: bp->wptr = bp->rptr;
129: qreply(q, bp);
130: return;
131: }
132:
133: case M_STOP:
134: k->c_state |= TTSTOP;
135: break;
136:
137: case M_START:
138: k->c_state &= ~TTSTOP;
139: kbdstart(k);
140: break;
141:
142: case M_FLUSH:
143: flushq(q, 0);
144: break;
145:
146: case M_DELAY:
147: case M_DATA:
148: putq(q, bp);
149: kbdstart(k);
150: return;
151:
152: default:
153: break;
154: }
155: freeb(bp);
156: }
157:
158: kbdtime(k)
159: register struct kbdld *k;
160: {
161: k->c_state &= ~TIMEOUT;
162: kbdstart(k);
163: }
164:
165: kbdstart(k)
166: register struct kbdld *k;
167: {
168: register s;
169: register struct block *bp;
170: register u_char *cp;
171:
172: if (k->cons_q==NULL)
173: return;
174: s = spl1();
175: while ((k->c_state & (TIMEOUT|TTSTOP))==0 && k->cons_q->count) {
176: bp = getq(k->cons_q);
177: switch (bp->type) {
178:
179: case M_DATA:
180: /* Must clear high bit for monitor */
181: for(cp = bp->rptr; cp < bp->wptr; cp++)
182: *cp &= 0177;
183: (*romp->v_fwritestr)(bp->rptr, bp->wptr - bp->rptr,
184: romp->v_fbaddr);
185: freeb(bp);
186: break;
187:
188: case M_DELAY:
189: timeout(kbdtime, (caddr_t)k, (int)*bp->rptr);
190: k->c_state |= TIMEOUT;
191: freeb(bp);
192: splx(s);
193: return;
194: default:
195: freeb(bp);
196: break;
197: }
198: }
199: splx(s);
200: }
201:
202: kbdldin(q, bp)
203: struct queue *q;
204: register struct block *bp;
205: {
206: register struct kbdld *k = (struct kbdld *)q->ptr;
207:
208: /* Pass along anything but data */
209: if (bp->type != M_DATA) {
210: (*q->next->qinfo->putp)(q->next, bp);
211: return;
212: }
213:
214: while (bp->rptr < bp->wptr)
215: kbdinput(*bp->rptr++, k);
216: freeb(bp);
217: while ((q->next->flag&QFULL)==0 && (bp = getq(q)))
218: (*q->next->qinfo->putp)(q->next, bp);
219: }
220:
221: /*
222: * keyboard server processing.
223: */
224: kbdisrv(q)
225: register struct queue *q;
226: {
227: register struct block *bp;
228:
229: while ((q->next->flag&QFULL)==0 && (bp = getq(q)))
230: (*q->next->qinfo->putp)(q->next, bp);
231: }
232:
233: /*
234: * kbdclick is used to remember the current click value of the
235: * Sun-3 keyboard. This brain damaged keyboard will reset the
236: * clicking to the "default" value after a reset command and
237: * there is no way to read out the current click value. We
238: * cannot send a click command immediately after the reset
239: * command or the keyboard gets screwed up. So we wait until
240: * we get the ID byte before we send back the click command.
241: * Unfortunately, this means that there is a small window
242: * where the keyboard can click when it really shouldn't be.
243: * A value of -1 means that kbdclick has not been initialized yet.
244: */
245: int kbdclick = -1;
246:
247: /*
248: * Send command byte to keyboard
249: */
250: kbdcmd(k, cmd)
251: register struct kbdld *k;
252: char cmd;
253: {
254: register struct queue *q = WR(k->key_q)->next;
255:
256: putd(q->qinfo->putp, q, cmd);
257: if (cmd == KBD_CMD_NOCLICK)
258: kbdclick = 0;
259: else if (cmd == KBD_CMD_CLICK)
260: kbdclick = 1;
261: }
262:
263: /*
264: * Reset the keyboard
265: */
266: kbdreset(k)
267: register struct kbdld *k;
268: {
269: k->k_idstate = KID_NONE;
270: k->k_state = NORMAL;
271: kbdcmd(k, KBD_CMD_RESET);
272: }
273:
274: kbdidletimeout(k)
275: register struct kbdld *k;
276: {
277: untimeout(kbdidletimeout, (caddr_t)k);
278: /*
279: * Double check that was waiting for idle timeout.
280: */
281: if (k->k_idstate == KID_IDLE)
282: kbdinput(IDLEKEY, k);
283: }
284:
285: /*
286: * Process a keypress
287: */
288: kbdinput(key, k)
289: register u_char key;
290: register struct kbdld *k;
291: {
292: switch (k->k_idstate) {
293:
294: case KID_NONE:
295: if (key == IDLEKEY) {
296: k->k_idstate = KID_IDLE;
297: timeout(kbdidletimeout, (caddr_t)k, hz/10);
298: } else if (key == RESETKEY)
299: k->k_idstate = KID_LKSUN2;
300: return;
301:
302: case KID_IDLE:
303: if (key == IDLEKEY)
304: kbdid(k, KB_KLUNK);
305: else if (key == RESETKEY)
306: k->k_idstate = KID_LKSUN2;
307: else if (key & 0x80)
308: kbdid(k, (int)(KB_VT100 | (key&0x40)));
309: else
310: kbdreset(k);
311: return;
312:
313: case KID_LKSUN2:
314: if (key == 0x02) { /* Sun-2 keyboard */
315: kbdid(k, KB_SUN2);
316: return;
317: }
318: if (key == 0x03) { /* Sun-3 keyboard */
319: kbdid(k, KB_SUN3);
320: /*
321: * We just did a reset command to a Sun-3 keyboard
322: * which sets the click back to the default
323: * (which is currently ON!). We use the kbdclick
324: * variable to see if the keyboard should be
325: * turned on or off. If it has not been set,
326: * then on a sun3 we use the eeprom to determine
327: * if the default value is on or off. In the
328: * sun2 case, we default to off.
329: */
330: switch (kbdclick) {
331: case 0:
332: kbdcmd(k, KBD_CMD_NOCLICK);
333: break;
334: case 1:
335: kbdcmd(k, KBD_CMD_CLICK);
336: break;
337: case -1:
338: default:
339: {
340: #ifdef sun3
341: #include "../sun3/eeprom.h"
342:
343: if (EEPROM->ee_diag.eed_keyclick ==
344: EED_KEYCLICK)
345: kbdcmd(k, KBD_CMD_CLICK);
346: else
347: #endif sun3
348: kbdcmd(k, KBD_CMD_NOCLICK);
349: }
350: break;
351: }
352: return;
353: }
354: kbdreset(k);
355: return;
356:
357: case KID_OK:
358: if (key == 0 || key == 0xFF) {
359: kbdreset(k);
360: return;
361: }
362: break;
363: }
364:
365: switch (k->k_state) {
366:
367: normalstate:
368: k->k_state = NORMAL;
369: case NORMAL:
370: if (k->k_curkeyboard && key == k->k_curkeyboard->k_abort1) {
371: k->k_state = ABORT1;
372: break;
373: }
374: kbdtranslate(k, key);
375: if (key == IDLEKEY)
376: k->k_state = IDLE1;
377: break;
378:
379: case IDLE1:
380: if (key & 0x80) { /* ID byte */
381: if (k->k_id == KB_VT100)
382: k->k_state = IDLE2;
383: else
384: kbdreset(k);
385: break;
386: }
387: if (key != IDLEKEY)
388: goto normalstate; /* real data */
389: break;
390:
391: case IDLE2:
392: if (key == IDLEKEY) k->k_state = IDLE1;
393: else goto normalstate;
394: break;
395:
396: case ABORT1:
397: if (k->k_curkeyboard) {
398: if (key == k->k_curkeyboard->k_abort2) {
399: DELAY(100000);
400: montrap(*romp->v_abortent);
401: k->k_state = NORMAL;
402: kbdtranslate(k, (u_char)IDLEKEY); /* fake */
403: return;
404: } else {
405: kbdtranslate(k, k->k_curkeyboard->k_abort1);
406: goto normalstate;
407: }
408: }
409: }
410: }
411:
412: kbdid(k, id)
413: register struct kbdld *k;
414: int id;
415: {
416: k->k_id = id & 0xF;
417: k->k_idstate = KID_OK;
418: k->k_shiftmask = 0;
419: if (id & 0x40)
420: /* Not a transition so don't send event */
421: k->k_shiftmask |= CAPSMASK;
422: k->k_buckybits = 0;
423: k->k_curkeyboard = keytables[k->k_id];
424: k->k_rptkey = IDLEKEY; /* Nothing happening now */
425: }
426:
427: /*
428: * This routine determines which table we should look in to decode
429: * the current keycode.
430: */
431: struct keymap *
432: settable(k, mask)
433: register struct kbdld *k;
434: register u_int mask;
435: {
436: register struct keyboard *kp;
437:
438: kp = k->k_curkeyboard;
439: if (kp == NULL)
440: return (NULL);
441: if (mask & UPMASK)
442: return (kp->k_up);
443: if (mask & CTRLMASK)
444: return (kp->k_control);
445: if (mask & SHIFTMASK)
446: return (kp->k_shifted);
447: if (mask & CAPSMASK)
448: return (kp->k_caps);
449: return (kp->k_normal);
450: }
451:
452: kbdrpt(k)
453: register struct kbdld *k;
454: {
455: kbdtranslate(k, k->k_rptkey);
456: if (k->k_rptkey != IDLEKEY)
457: timeout(kbdrpt, (caddr_t)k, kbd_repeatrate);
458: }
459:
460: kbdcancelrpt(k)
461: register struct kbdld *k;
462: {
463: if (k->k_rptkey != IDLEKEY) {
464: untimeout(kbdrpt, (caddr_t)k);
465: k->k_rptkey = IDLEKEY;
466: }
467: }
468:
469: kbdtranslate(k, keycode)
470: register struct kbdld *k;
471: register u_char keycode;
472: {
473: register u_char key, newstate, entry;
474: register u_char enF0;
475: register char *cp;
476: struct keymap *km;
477: register struct queue *q = k->key_q;
478:
479: newstate = STATEOF(keycode);
480: key = KEYOF(keycode);
481:
482: km = settable(k, (u_int)(k->k_shiftmask | newstate));
483: if (km == NULL) { /* gross error */
484: kbdcancelrpt(k);
485: return;
486: }
487: entry = km->keymap[key];
488: enF0 = entry & 0xF0;
489: /*
490: * Handle the state of toggle shifts specially.
491: * Toggle shifts should only come on downs.
492: */
493: if (((entry >> 4) == (SHIFTKEYS >> 4)) &&
494: ((1 << (entry & 0x0F)) & k->k_curkeyboard->k_toggleshifts)) {
495: if ((1 << (entry & 0x0F)) & k->k_togglemask) {
496: newstate = RELEASED;
497: } else {
498: newstate = PRESSED;
499: }
500: }
501:
502: if (newstate == PRESSED && entry != NOSCROLL &&
503: enF0 != SHIFTKEYS && enF0 != BUCKYBITS &&
504: !(entry >= LEFTFUNC && entry <= BOTTOMFUNC+15)) {
505: if (k->k_rptkey != keycode) {
506: kbdcancelrpt(k);
507: timeout(kbdrpt, (caddr_t)k, kbd_repeatdelay);
508: k->k_rptkey = keycode;
509: }
510: } else if (key == KEYOF(k->k_rptkey)) /* key going up */
511: kbdcancelrpt(k);
512:
513: switch (entry >> 4) {
514:
515: case 0: case 1: case 2: case 3:
516: case 4: case 5: case 6: case 7:
517: putd(putq, q, entry | k->k_buckybits);
518: break;
519:
520: case SHIFTKEYS >> 4: {
521: u_int shiftbit = 1 << (entry & 0x0F);
522:
523: /* Modify toggle state (see toggle processing above) */
524: if (shiftbit & k->k_curkeyboard->k_toggleshifts) {
525: if (newstate == RELEASED) {
526: k->k_togglemask &= ~shiftbit;
527: k->k_shiftmask &= ~shiftbit;
528: } else {
529: k->k_togglemask |= shiftbit;
530: k->k_shiftmask |= shiftbit;
531: }
532: } else
533: k->k_shiftmask ^= shiftbit;
534: break;
535: }
536:
537: case BUCKYBITS >> 4:
538: k->k_buckybits ^= 1 << (7 + (entry & 0x0F));
539: break;
540:
541: case FUNNY >> 4:
542: switch (entry) {
543: case NOP:
544: break;
545:
546: /*
547: * NOSCROLL/CTRLS/CTRLQ exist so that these keys, on keyboards
548: * with NOSCROLL, interact smoothly. If a user changes
549: * his tty output control keys to be something other than those
550: * in keytables for CTRLS & CTRLQ then he effectively disables
551: * his NOSCROLL key. One could imagine computing CTRLS & CTRLQ
552: * dynamically by watching TIOCSETC ioctl's go by in kbdioctl.
553: */
554: case NOSCROLL:
555: if (k->k_shiftmask & CTLSMASK) goto sendcq;
556: else goto sendcs;
557:
558: case CTRLS:
559: sendcs:
560: k->k_shiftmask |= CTLSMASK;
561: putd(putq, q, ('S'-0x40) | k->k_buckybits);
562: break;
563:
564: case CTRLQ:
565: sendcq:
566: putd(putq, q, ('Q'-0x40) | k->k_buckybits);
567: k->k_shiftmask &= ~CTLSMASK;
568: break;
569:
570: case IDLE:
571: /*
572: * Minor hack to prevent keyboards unplugged
573: * in caps lock from retaining their capslock
574: * state when replugged. This should be
575: * solved by using the capslock info in the
576: * KBDID byte.
577: */
578: if (keycode == NOTPRESENT)
579: k->k_shiftmask = 0;
580: /* Fall thru into RESET code */
581:
582: case RESET:
583: gotreset:
584: k->k_shiftmask &= k->k_curkeyboard->k_idleshifts;
585: k->k_shiftmask |= k->k_togglemask;
586: k->k_buckybits &= k->k_curkeyboard->k_idlebuckys;
587: kbdcancelrpt(k);
588: break;
589:
590: case ERROR:
591: printf("kbd: Error detected\r\n");
592: goto gotreset;
593:
594: /*
595: * Remember when adding new entries that,
596: * if they should NOT auto-repeat,
597: * they should be put into the IF statement
598: * just above this switch block.
599: */
600: default:
601: goto badentry;
602: }
603: break;
604:
605: case STRING >> 4:
606: cp = &keystringtab[entry & 0x0F][0];
607: while (*cp != '\0') {
608: putd(putq, q, *cp);
609: cp++;
610: }
611: break;
612:
613: /*
614: * Remember when adding new entries that,
615: * if they should NOT auto-repeat,
616: * they should be put into the IF statement
617: * just above this switch block.
618: */
619: default:
620: if (entry >= LEFTFUNC && entry <= BOTTOMFUNC+15) {
621: char buf[10], *strsetwithdecimal();
622:
623: if (newstate == RELEASED)
624: break;
625: cp = strsetwithdecimal(&buf[0], (u_int)entry,
626: sizeof (buf) - 1);
627: putd(putq, q, '\033');
628: putd(putq, q, '[');
629: while (*cp != '\0') {
630: putd(putq, q, *cp);
631: cp++;
632: }
633: putd(putq, q, 'z');
634: }
635: badentry:
636: break;
637: }
638: }
639:
640: char *
641: strsetwithdecimal(buf, val, maxdigs)
642: char *buf;
643: u_int val, maxdigs;
644: {
645: int hradix = 5;
646: char *bp;
647: int lowbit;
648: char *tab = "0123456789abcdef";
649:
650: bp = buf + maxdigs;
651: *(--bp) = '\0';
652: while (val) {
653: lowbit = val & 1;
654: val = (val >> 1);
655: *(--bp) = tab[val % hradix * 2 + lowbit];
656: val /= hradix;
657: }
658: return (bp);
659: }
660: #endif NKBD > 0
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.