2 * Copyright (c) 1999 Hellmuth Michaelis
4 * Copyright (c) 1992, 1995 Hellmuth Michaelis and Joerg Wunsch.
6 * Copyright (c) 1992, 1993 Brian Dunford-Shore and Holger Veit.
10 * This code is derived from software contributed to Berkeley by
11 * William Jolitz and Don Ahn.
13 * This code is derived from software contributed to 386BSD by
16 * Redistribution and use in source and binary forms, with or without
17 * modification, are permitted provided that the following conditions
19 * 1. Redistributions of source code must retain the above copyright
20 * notice, this list of conditions and the following disclaimer.
21 * 2. Redistributions in binary form must reproduce the above copyright
22 * notice, this list of conditions and the following disclaimer in the
23 * documentation and/or other materials provided with the distribution.
24 * 3. All advertising materials mentioning features or use of this software
25 * must display the following acknowledgement:
26 * This product includes software developed by Hellmuth Michaelis,
27 * Brian Dunford-Shore and Joerg Wunsch.
28 * 4. The name authors may not be used to endorse or promote products
29 * derived from this software without specific prior written permission.
31 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
32 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
33 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
34 * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
35 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
36 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
37 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
38 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
39 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
40 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
43 /*---------------------------------------------------------------------------*
45 * pcvt_kbd.c VT220 Driver Keyboard Interface Code
46 * ----------------------------------------------------
48 * Last Edit-Date: [Mon Dec 27 14:01:50 1999]
50 * $FreeBSD: src/sys/i386/isa/pcvt/pcvt_kbd.c,v 1.32.2.1 2000/10/29 16:59:28 dwmalone Exp $
52 *---------------------------------------------------------------------------*/
59 #include <i386/isa/pcvt/pcvt_hdr.h> /* global include */
61 #define LEDSTATE_UPDATE_PENDING (1 << 3)
63 static void fkey1(void), fkey2(void), fkey3(void), fkey4(void);
64 static void fkey5(void), fkey6(void), fkey7(void), fkey8(void);
65 static void fkey9(void), fkey10(void), fkey11(void), fkey12(void);
67 static void sfkey1(void), sfkey2(void), sfkey3(void), sfkey4(void);
68 static void sfkey5(void), sfkey6(void), sfkey7(void), sfkey8(void);
69 static void sfkey9(void), sfkey10(void), sfkey11(void), sfkey12(void);
71 static void cfkey1(void), cfkey2(void), cfkey3(void), cfkey4(void);
72 static void cfkey5(void), cfkey6(void), cfkey7(void), cfkey8(void);
73 static void cfkey9(void), cfkey10(void), cfkey11(void), cfkey12(void);
75 static void doreset ( void );
76 static void ovlinit ( int force );
77 static void settpmrate ( int rate );
78 static void setlockkeys ( int snc );
79 #ifndef _DEV_KBD_KBDREG_H_
80 static int kbc_8042cmd ( int val );
81 #endif /* !_DEV_KBD_KBDREG_H_ */
82 static int getokeydef ( unsigned key, struct kbd_ovlkey *thisdef );
83 static int getckeydef ( unsigned key, struct kbd_ovlkey *thisdef );
84 static int rmkeydef ( int key );
85 static int setkeydef ( struct kbd_ovlkey *data );
86 static u_char * xlatkey2ascii( U_short key );
88 static int ledstate = LEDSTATE_UPDATE_PENDING; /* keyboard led's */
89 static int tpmrate = KBD_TPD500|KBD_TPM100;
90 static u_char altkpflag = 0;
91 static u_short altkpval = 0;
93 static u_short *scrollback_savedscreen = (u_short *)0;
94 static size_t scrnsv_size = (size_t)-1;
95 static void scrollback_save_screen ( void );
96 static void scrollback_restore_screen ( void );
102 #include <i386/isa/pcvt/pcvt_kbd.h> /* tables etc */
105 /*---------------------------------------------------------------------------*
106 * keyboard debugging: put kbd communication char into some buffer
107 *---------------------------------------------------------------------------*/
108 static void showkey (char delim, u_char val)
112 for(rki = 3; rki < 80; rki++) /* shift left buffer */
113 rawkeybuf[rki-3] = rawkeybuf[rki];
115 rawkeybuf[77] = delim; /* delimiter */
117 rki = (val & 0xf0) >> 4; /* ms nibble */
122 rki = rki - 10 + 'A';
126 rki = val & 0x0f; /* ls nibble */
131 rki = rki - 10 + 'A';
135 #endif /* PCVT_SHOWKEYS */
137 /*---------------------------------------------------------------------------*
138 * function to switch to another virtual screen
139 *---------------------------------------------------------------------------*/
143 if(critical_scroll) /* executing critical region ? */
144 switch_page = page; /* yes, auto switch later */
146 vgapage(page); /* no, switch now */
151 * This code from Lon Willett enclosed in #if PCVT_UPDLED_LOSES_INTR is
152 * abled because it crashes FreeBSD 1.1.5.1 at boot time.
153 * The cause is obviously that the timeout queue is not yet initialized
154 * timeout is called from here the first time.
155 * Anyway it is a pointer in the right direction so it is included for
159 #define PCVT_UPDLED_LOSES_INTR 0 /* disabled for now */
161 #if PCVT_UPDLED_LOSES_INTR || defined(_DEV_KBD_KBDREG_H_)
163 /*---------------------------------------------------------------------------*
164 * check for lost keyboard interrupts
165 *---------------------------------------------------------------------------*/
168 * The two commands to change the LEDs generate two KEYB_R_ACK responses
169 * from the keyboard, which aren't explicitly checked for (maybe they
170 * should be?). However, when a lot of other I/O is happening, one of
171 * the interrupts sometimes gets lost (I'm not sure of the details of
172 * how and why and what hardware this happens with).
174 * This may have had something to do with spltty() previously not being
175 * called before the kbd_cmd() calls in update_led().
177 * This is a real problem, because normally the keyboard is only polled
178 * by pcrint(), and no more interrupts will be generated until the ACK
179 * has been read. So the keyboard is hung. This code polls a little
180 * while after changing the LEDs to make sure that this hasn't happened.
182 * XXX Quite possibly we should poll the kbd on a regular basis anyway,
183 * in the interest of robustness. It may be possible that interrupts
184 * get lost other times as well.
187 static int lost_intr_timeout_queued = 0;
188 static struct callout_handle lost_intr_ch =
189 CALLOUT_HANDLE_INITIALIZER(&lost_intr_ch);
192 check_for_lost_intr (void *arg)
194 #ifndef _DEV_KBD_KBDREG_H_
195 lost_intr_timeout_queued = 0;
196 if (inb(CONTROLLER_CTRL) & STATUS_OUTPBF)
198 int opri = spltty ();
205 lost_intr_timeout_queued = 0;
206 if (kbd && (*kbdsw[kbd->kb_index]->lock)(kbd, TRUE)) {
208 (*kbdsw[kbd->kb_index]->lock)(kbd, FALSE);
209 if ((*kbdsw[kbd->kb_index]->check)(kbd))
214 lost_intr_ch = timeout(check_for_lost_intr, (void *)NULL, hz);
215 lost_intr_timeout_queued = 1;
216 #endif /* !_DEV_KBD_KBDREG_H_ */
219 #endif /* PCVT_UPDLED_LOSES_INTR || defined(_DEV_KBD_KBDREG_H_) */
221 /*---------------------------------------------------------------------------*
222 * update keyboard led's
223 *---------------------------------------------------------------------------*/
227 #if !PCVT_NO_LED_UPDATE
229 /* Don't update LED's unless necessary. */
231 int opri, new_ledstate;
234 #ifndef _DEV_KBD_KBDREG_H_
235 new_ledstate = (vsp->scroll_lock) |
236 (vsp->num_lock * 2) |
237 (vsp->caps_lock * 4);
239 new_ledstate = ((vsp->scroll_lock) ? LED_SCR : 0) |
240 ((vsp->num_lock) ? LED_NUM : 0) |
241 ((vsp->caps_lock) ? LED_CAP : 0);
242 #endif /* _DEV_KBD_KBDREG_H_ */
244 if (new_ledstate != ledstate)
246 #ifndef _DEV_KBD_KBDREG_H_
247 int response1, response2;
249 ledstate = LEDSTATE_UPDATE_PENDING;
251 if(kbd_cmd(KEYB_C_LEDS) != 0)
253 printf("Keyboard LED command timeout\n");
259 * For some keyboards or keyboard controllers, it is an
260 * error to issue a command without waiting long enough
261 * for an ACK for the previous command. The keyboard
262 * gets confused, and responds with KEYB_R_RESEND, but
263 * we ignore that. Wait for the ACK here. The busy
264 * waiting doesn't matter much, since we lose anyway by
265 * busy waiting to send the command.
267 * XXX actually wait for any response, since we can't
268 * handle normal scancodes here.
270 * XXX all this should be interrupt driven. Issue only
271 * one command at a time wait for a ACK before proceeding.
272 * Retry after a timeout or on receipt of a KEYB_R_RESEND.
273 * KEYB_R_RESENDs seem to be guaranteed by working
274 * keyboard controllers with broken (or disconnected)
275 * keyboards. There is another code for keyboard
276 * reconnects. The keyboard hardware is very simple and
279 response1 = kbd_response();
281 if(kbd_cmd(new_ledstate) != 0) {
282 printf("Keyboard LED data timeout\n");
286 response2 = kbd_response();
288 if (response1 == KEYB_R_ACK && response2 == KEYB_R_ACK)
289 ledstate = new_ledstate;
292 "Keyboard LED command not ACKed (responses %#x %#x)\n",
293 response1, response2);
294 #else /* _DEV_KBD_KBDREG_H_ */
297 ledstate = new_ledstate;
300 ledstate = LEDSTATE_UPDATE_PENDING;
302 if ((*kbdsw[kbd->kb_index]->ioctl)(kbd, KDSETLED,
303 (caddr_t)&new_ledstate) == 0)
304 ledstate = new_ledstate;
307 #endif /* !_DEV_KBD_KBDREG_H_ */
309 #if PCVT_UPDLED_LOSES_INTR
310 if (lost_intr_timeout_queued)
311 untimeout(check_for_lost_intr, NULL, lost_intr_ch);
313 lost_intr_ch = timeout(check_for_lost_intr, NULL, hz);
314 lost_intr_timeout_queued = 1;
315 #endif /* PCVT_UPDLED_LOSES_INTR */
319 #ifndef _DEV_KBD_KBDREG_H_
323 #endif /* !PCVT_NO_LED_UPDATE */
326 /*---------------------------------------------------------------------------*
328 *---------------------------------------------------------------------------*/
332 #ifndef _DEV_KBD_KBDREG_H_
333 tpmrate = rate & 0x7f;
334 if(kbd_cmd(KEYB_C_TYPEM) != 0)
335 printf("Keyboard TYPEMATIC command timeout\n");
336 else if(kbd_cmd(tpmrate) != 0)
337 printf("Keyboard TYPEMATIC data timeout\n");
341 tpmrate = rate & 0x7f;
342 if ((*kbdsw[kbd->kb_index]->ioctl)(kbd, KDSETRAD, (caddr_t)&tpmrate))
343 printf("pcvt: failed to set keyboard TYPEMATIC.\n");
344 #endif /* !_DEV_KBD_KBDREG_H_ */
347 #ifndef _DEV_KBD_KBDREG_H_
348 /*---------------------------------------------------------------------------*
349 * Pass command to keyboard controller (8042)
350 *---------------------------------------------------------------------------*/
356 timeo = 100000; /* > 100 msec */
357 while (inb(CONTROLLER_CTRL) & STATUS_INPBF)
360 outb(CONTROLLER_CTRL, val);
364 /*---------------------------------------------------------------------------*
365 * Pass command to keyboard itself
366 *---------------------------------------------------------------------------*/
372 timeo = 100000; /* > 100 msec */
373 while (inb(CONTROLLER_CTRL) & STATUS_INPBF)
376 outb(CONTROLLER_DATA, val);
380 #endif /* PCVT_SHOWKEYS */
385 /*---------------------------------------------------------------------------*
386 * Read response from keyboard
387 * NB: make sure to call spltty() before kbd_cmd(), kbd_response().
388 *---------------------------------------------------------------------------*/
395 timeo = 500000; /* > 500 msec (KEYB_R_SELFOK requires 87) */
396 while (!(inb(CONTROLLER_CTRL) & STATUS_OUTPBF))
400 PCVT_KBD_DELAY(); /* 7 us delay */
401 ch = inb(CONTROLLER_DATA);
405 #endif /* PCVT_SHOWKEYS */
409 #endif /* _DEV_KBD_KBDREG_H_ */
412 /*---------------------------------------------------------------------------*
413 * switch PC scan code emulation mode
414 *---------------------------------------------------------------------------*/
416 kbd_emulate_pc(int do_emulation)
418 #ifndef _DEV_KBD_KBDREG_H_
419 int cmd, timeo = 10000;
421 cmd = COMMAND_SYSFLG|COMMAND_IRQEN; /* common base cmd */
424 cmd |= COMMAND_INHOVR;
428 cmd |= COMMAND_PCSCAN;
430 kbc_8042cmd(CONTR_WRITE);
431 while (inb(CONTROLLER_CTRL) & STATUS_INPBF)
434 outb(CONTROLLER_DATA, cmd);
436 set_controller_command_byte(*(KBDC *)kbd->kb_data, KBD_TRANSLATION,
437 (do_emulation) ? KBD_TRANSLATION : 0);
438 #endif /* !_DEV_KBD_KBDREG_H_ */
441 #endif /* PCVT_SCANSET > 1 */
444 #ifndef PCVT_NONRESP_KEYB_TRY
445 #define PCVT_NONRESP_KEYB_TRY 25 /* no of times to try to detect */
446 #endif /* a nonresponding keyboard */
448 /*---------------------------------------------------------------------------*
449 * try to force keyboard into a known state ..
450 *---------------------------------------------------------------------------*/
454 #ifndef _DEV_KBD_KBDREG_H_
459 /* Enable interrupts and keyboard, etc. */
460 if (kbc_8042cmd(CONTR_WRITE) != 0)
461 printf("pcvt: doreset() - timeout controller write command\n");
463 #if PCVT_USEKBDSEC /* security enabled */
465 # if PCVT_SCANSET == 2
466 # define KBDINITCMD COMMAND_SYSFLG|COMMAND_IRQEN
467 # else /* PCVT_SCANSET != 2 */
468 # define KBDINITCMD COMMAND_PCSCAN|COMMAND_SYSFLG|COMMAND_IRQEN
469 # endif /* PCVT_SCANSET == 2 */
471 #else /* ! PCVT_USEKBDSEC */ /* security disabled */
473 # if PCVT_SCANSET == 2
474 # define KBDINITCMD COMMAND_INHOVR|COMMAND_SYSFLG|COMMAND_IRQEN
475 # else /* PCVT_SCANSET != 2 */
476 # define KBDINITCMD COMMAND_PCSCAN|COMMAND_INHOVR|COMMAND_SYSFLG\
478 # endif /* PCVT_SCANSET == 2 */
480 #endif /* PCVT_USEKBDSEC */
482 if (kbd_cmd(KBDINITCMD) != 0)
483 printf("pcvt: doreset() - timeout writing keyboard init command\n");
486 * Discard any stale keyboard activity. The 0.1 boot code isn't
487 * very careful and sometimes leaves a KEYB_R_RESEND. Versions
488 * between 1992 and Oct 1996 didn't have the delay and sometimes
489 * left a KEYB_R_RESEND.
492 if (inb(CONTROLLER_CTRL) & STATUS_OUTPBF)
496 if (!(inb(CONTROLLER_CTRL) & STATUS_OUTPBF))
501 /* Start keyboard reset */
505 if (kbd_cmd(KEYB_C_RESET) != 0)
507 printf("pcvt: doreset() - timeout for keyboard reset command\n");
508 outb(CONTROLLER_DATA, KEYB_C_RESET); /* force */
511 /* Wait for the first response to reset and handle retries */
512 while ((response = kbd_response()) != KEYB_R_ACK)
516 if(!again) /* print message only once ! */
517 printf("pcvt: doreset() - response != ack and response < 0 [one time only msg]\n");
518 response = KEYB_R_RESEND;
520 else if (response == KEYB_R_RESEND)
522 if(!again) /* print message only once ! */
523 printf("pcvt: doreset() - got KEYB_R_RESEND response ... [one time only msg]\n");
525 if (response == KEYB_R_RESEND)
527 if(++again > PCVT_NONRESP_KEYB_TRY)
529 printf("pcvt: doreset() - Caution - no PC keyboard detected!\n");
530 keyboard_type = KB_UNKNOWN;
535 if((kbd_cmd(KEYB_C_RESET) != 0) && (once == 0))
537 once++; /* print message only once ! */
538 printf("pcvt: doreset() - timeout for loop keyboard reset command [one time only msg]\n");
539 outb(CONTROLLER_DATA, KEYB_C_RESET); /* force */
544 /* Wait for the second response to reset */
546 while ((response = kbd_response()) != KEYB_R_SELFOK)
550 printf("pcvt: doreset() - response != OK and resonse < 0\n");
552 * If KEYB_R_SELFOK never arrives, the loop will
553 * finish here unless the keyboard babbles or
554 * STATUS_OUTPBF gets stuck.
566 if(kbd_cmd(KEYB_C_ID) != 0)
568 printf("pcvt: doreset() - timeout for keyboard ID command\n");
569 keyboard_type = KB_UNKNOWN;
576 if((response = kbd_response()) == KEYB_R_MF2ID1)
578 if((response = kbd_response()) == KEYB_R_MF2ID2)
580 keyboard_type = KB_MFII;
582 else if(response == KEYB_R_MF2ID2HP)
584 keyboard_type = KB_MFII;
588 printf("\npcvt: doreset() - kbdid, response 2 = [%d]\n",
590 keyboard_type = KB_UNKNOWN;
593 else if (response == KEYB_R_ACK)
597 else if (response == -1)
599 keyboard_type = KB_AT;
603 printf("\npcvt: doreset() - kbdid, response 1 = [%d]\n", response);
609 #else /* PCVT_KEYBDID */
611 keyboard_type = KB_MFII; /* force it .. */
613 #endif /* PCVT_KEYBDID */
615 #else /* _DEV_KBD_KBDREG_H_ */
618 if (!reset_keyboard) /* no, we are not ready to reset */
621 if (lost_intr_timeout_queued) {
622 untimeout(check_for_lost_intr, (void *)NULL, lost_intr_ch);
623 lost_intr_timeout_queued = 0;
627 return; /* shouldn't happen */
630 ledstate = LEDSTATE_UPDATE_PENDING;
632 #if PCVT_USEKBDSEC /* security enabled */
634 # if PCVT_SCANSET == 2
635 # define KBDINITCMD 0
636 # else /* PCVT_SCANSET != 2 */
637 # define KBDINITCMD KBD_TRANSLATION
638 # endif /* PCVT_SCANSET == 2 */
640 #else /* ! PCVT_USEKBDSEC */ /* security disabled */
642 # if PCVT_SCANSET == 2
643 # define KBDINITCMD KBD_OVERRIDE_KBD_LOCK
644 # else /* PCVT_SCANSET != 2 */
645 # define KBDINITCMD KBD_TRANSLATION | KBD_OVERRIDE_KBD_LOCK
646 # endif /* PCVT_SCANSET == 2 */
648 #endif /* PCVT_USEKBDSEC */
650 set_controller_command_byte(*(KBDC *)kbd->kb_data,
651 KBD_OVERRIDE_KBD_LOCK | KBD_TRANSLATION, KBDINITCMD);
653 keyboard_type = KB_MFII; /* force it .. */
656 (*kbdsw[kbd->kb_index]->ioctl)(kbd, KDGKBTYPE, (caddr_t)&type);
660 keyboard_type = KB_AT;
663 keyboard_type = KB_MFII;
666 keyboard_type = KB_UNKNOWN;
669 #endif /* PCVT_KEYBDID */
673 lost_intr_ch = timeout(check_for_lost_intr, (void *)NULL, hz);
674 lost_intr_timeout_queued = 1;
676 #endif /* !_DEV_KBD_KBDREG_H_ */
679 /*---------------------------------------------------------------------------*
681 *---------------------------------------------------------------------------*/
687 keyboard_is_initialized = 1;
690 /*---------------------------------------------------------------------------*
691 * init keyboard code, this initializes the keyboard subsystem
692 * just "a bit" so the very very first ddb session is able to
693 * get proper keystrokes - in other words, it's a hack ....
694 *---------------------------------------------------------------------------*/
699 keyboard_is_initialized = 1;
702 /*---------------------------------------------------------------------------*
703 * init keyboard overlay table
704 *---------------------------------------------------------------------------*/
706 void ovlinit(int force)
710 if(force || ovlinitflag==0)
712 if(ovlinitflag == 0 &&
713 (ovltbl = (Ovl_tbl *)malloc(sizeof(Ovl_tbl) * OVLTBL_SIZE,
714 M_DEVBUF, M_WAITOK)) == NULL)
715 panic("pcvt_kbd: malloc of Ovl_tbl failed");
717 for(i=0; i<OVLTBL_SIZE; i++)
721 ovltbl[i].unshift[0] =
724 ovltbl[i].altgr[0] = 0;
728 ovltbl[i].suba = KBD_SUBT_STR; /* just strings .. */
730 for(i=0; i<=MAXKEYNUM; i++)
731 key2ascii[i].type &= KBD_MASK;
736 /*---------------------------------------------------------------------------*
737 * get original key definition
738 *---------------------------------------------------------------------------*/
740 getokeydef(unsigned key, Ovl_tbl *thisdef)
742 if(key == 0 || key > MAXKEYNUM)
745 thisdef->keynum = key;
746 thisdef->type = key2ascii[key].type;
748 if(key2ascii[key].unshift.subtype == STR)
750 bcopy((u_char *)(key2ascii[key].unshift.what.string),
751 thisdef->unshift, CODE_SIZE);
752 thisdef->subu = KBD_SUBT_STR;
756 bcopy("", thisdef->unshift, CODE_SIZE);
757 thisdef->subu = KBD_SUBT_FNC;
760 if(key2ascii[key].shift.subtype == STR)
762 bcopy((u_char *)(key2ascii[key].shift.what.string),
763 thisdef->shift, CODE_SIZE);
764 thisdef->subs = KBD_SUBT_STR;
768 bcopy("",thisdef->shift,CODE_SIZE);
769 thisdef->subs = KBD_SUBT_FNC;
772 if(key2ascii[key].ctrl.subtype == STR)
774 bcopy((u_char *)(key2ascii[key].ctrl.what.string),
775 thisdef->ctrl, CODE_SIZE);
776 thisdef->subc = KBD_SUBT_STR;
780 bcopy("",thisdef->ctrl,CODE_SIZE);
781 thisdef->subc = KBD_SUBT_FNC;
784 /* deliver at least anything for ALTGR settings ... */
786 if(key2ascii[key].unshift.subtype == STR)
788 bcopy((u_char *)(key2ascii[key].unshift.what.string),
789 thisdef->altgr, CODE_SIZE);
790 thisdef->suba = KBD_SUBT_STR;
794 bcopy("",thisdef->altgr, CODE_SIZE);
795 thisdef->suba = KBD_SUBT_FNC;
800 /*---------------------------------------------------------------------------*
801 * get current key definition
802 *---------------------------------------------------------------------------*/
804 getckeydef(unsigned key, Ovl_tbl *thisdef)
806 u_short type = key2ascii[key].type;
811 if(type & KBD_OVERLOAD)
812 *thisdef = ovltbl[key2ascii[key].ovlindex];
814 getokeydef(key,thisdef);
819 /*---------------------------------------------------------------------------*
820 * translate keynumber and returns ptr to associated ascii string
821 * if key is bound to a function, executes it, and ret empty ptr
822 *---------------------------------------------------------------------------*/
824 xlatkey2ascii(U_short key)
826 static u_char capchar[2] = {0, 0};
828 static u_char metachar[3] = {0x1b, 0, 0};
830 static u_char metachar[2] = {0, 0};
832 static Ovl_tbl thisdef;
836 if(key==0) /* ignore the NON-KEY */
839 getckeydef(key&0x7F, &thisdef); /* get the current ASCII value */
841 thisdef.type &= KBD_MASK;
843 if(key&0x80) /* special handling of ALT-KEYPAD */
845 /* is the ALT Key released? */
846 if(thisdef.type==KBD_META || thisdef.type==KBD_ALTGR)
848 if(altkpflag) /* have we been in altkp mode? */
850 capchar[0] = altkpval;
859 switch(thisdef.type) /* convert the keys */
869 more_chars = (u_char *)thisdef.altgr;
871 else if(!ctrl_down && (shift_down || vsp->shift_lock))
873 if(key2ascii[key].shift.subtype == STR)
874 more_chars = (u_char *)thisdef.shift;
876 fnc = key2ascii[key].shift.what.func;
881 if(key2ascii[key].ctrl.subtype == STR)
882 more_chars = (u_char *)thisdef.ctrl;
884 fnc = key2ascii[key].ctrl.what.func;
889 if(key2ascii[key].unshift.subtype == STR)
890 more_chars = (u_char *)thisdef.unshift;
892 fnc = key2ascii[key].unshift.what.func;
896 (*fnc)(); /* execute function */
898 if((more_chars != NULL) && (more_chars[1] == 0))
900 if(vsp->caps_lock && more_chars[0] >= 'a'
901 && more_chars[0] <= 'z')
903 capchar[0] = *more_chars - ('a'-'A');
904 more_chars = capchar;
909 metachar[1] = *more_chars;
911 metachar[0] = *more_chars | 0x80;
913 more_chars = metachar;
946 if(meta_down || altgr_down)
948 if((n = keypad2num[key-91]) >= 0)
952 /* start ALT-KP mode */
966 if(key2ascii[key].shift.subtype == STR)
967 more_chars = (u_char *)thisdef.shift;
969 fnc = key2ascii[key].shift.what.func;
973 if(key2ascii[key].unshift.subtype == STR)
974 more_chars = (u_char *)thisdef.unshift;
976 fnc = key2ascii[key].unshift.what.func;
980 (*fnc)(); /* execute function */
989 if(key2ascii[key].shift.subtype == STR)
990 more_chars = (u_char *)thisdef.shift;
992 fnc = key2ascii[key].shift.what.func;
996 if(key2ascii[key].unshift.subtype == STR)
997 more_chars = (u_char *)thisdef.unshift;
999 fnc = key2ascii[key].unshift.what.func;
1003 (*fnc)(); /* execute function */
1006 case KBD_NUM: /* special kp-num handling */
1011 more_chars = (u_char *)"\033OP"; /* PF1 */
1023 if(!(vsp->num_lock))
1025 more_chars = (u_char *)thisdef.shift;
1029 more_chars = (u_char *)thisdef.unshift;
1031 if(vsp->lnm && (*more_chars == '\r'))
1033 more_chars = (u_char *)"\r\n"; /* CR LF */
1038 metachar[1] = *more_chars;
1040 metachar[0] = *more_chars | 0x80;
1042 more_chars = metachar;
1046 case KBD_META: /* these keys are */
1047 case KBD_ALTGR: /* handled directly */
1048 case KBD_SCROLL: /* by the keyboard */
1049 case KBD_CAPS: /* handler - they are */
1050 case KBD_SHFTLOCK: /* ignored here */
1058 /*---------------------------------------------------------------------------*
1059 * get keystrokes from the keyboard.
1060 * if noblock = 0, wait until a key is pressed.
1061 * else return NULL if no characters present.
1062 *---------------------------------------------------------------------------*/
1065 extern u_char pcvt_kbd_fifo[];
1066 extern int pcvt_kbd_rptr;
1067 extern short pcvt_kbd_count;
1078 #if PCVT_KBD_FIFO && PCVT_SLOW_INTERRUPT
1082 static u_char kbd_lastkey = 0; /* last keystroke */
1086 u_char extended: 1; /* extended prefix seen */
1087 u_char ext1: 1; /* extended prefix 1 seen */
1088 u_char breakseen: 1; /* break code seen */
1089 u_char vshift: 1; /* virtual shift pending */
1090 u_char vcontrol: 1; /* virtual control pending */
1091 u_char sysrq: 1; /* sysrq pressed */
1095 static char keybuf[2] = {0}; /* the second 0 is a delimiter! */
1096 #endif /* XSERVER */
1098 #ifdef _DEV_KBD_KBDREG_H_
1100 #endif /* _DEV_KBD_KBDREG_H_ */
1104 if(noblock == 31337)
1112 #ifndef _DEV_KBD_KBDREG_H_
1116 /* see if there is data from the keyboard available either from */
1117 /* the keyboard fifo or from the 8042 keyboard controller */
1119 if (pcvt_kbd_count || (inb(CONTROLLER_CTRL) & STATUS_OUTPBF))
1121 if (!pcvt_kbd_count) /* source = 8042 */
1123 PCVT_KBD_DELAY(); /* 7 us delay */
1124 dt = inb(CONTROLLER_DATA); /* get from obuf */
1126 else /* source = keyboard fifo */
1128 dt = pcvt_kbd_fifo[pcvt_kbd_rptr++];
1129 PCVT_DISABLE_INTR();
1132 if (pcvt_kbd_rptr >= PCVT_KBD_FIFO_SZ)
1136 #else /* !PCVT_KB_FIFO */
1138 /* see if there is data from the keyboard available from the 8042 */
1140 if (inb(CONTROLLER_CTRL) & STATUS_OUTPBF)
1142 PCVT_KBD_DELAY(); /* 7 us delay */
1143 dt = inb(CONTROLLER_DATA); /* yes, get data */
1145 #endif /* !PCVT_KBD_FIFO */
1147 #else /* _DEV_KBD_KBDREG_H_ */
1150 if (pcvt_kbd_count) {
1151 dt = pcvt_kbd_fifo[pcvt_kbd_rptr++];
1152 PCVT_DISABLE_INTR();
1155 if (pcvt_kbd_rptr >= PCVT_KBD_FIFO_SZ)
1158 #endif /* PCVT_KBD_FIFO */
1160 while ((c = (*kbdsw[kbd->kb_index]->read)(kbd, TRUE)) == -1)
1164 if ((c = (*kbdsw[kbd->kb_index]->read)(kbd, FALSE)) == -1)
1171 #endif /* !_DEV_KBD_KBDREG_H_ */
1174 * If x mode is active, only care for locking keys, then
1175 * return the scan code instead of any key translation.
1176 * Additionally, this prevents us from any attempts to
1177 * execute pcvt internal functions caused by keys (such
1178 * as screen flipping).
1179 * XXX For now, only the default locking key definitions
1180 * are recognized (i.e. if you have overloaded you "A" key
1181 * as NUMLOCK, that wont effect X mode:-)
1182 * Changing this would be nice, but would require modifi-
1183 * cations to the X server. After having this, X will
1184 * deal with the LEDs itself, so we are committed.
1187 * Iff PCVT_USL_VT_COMPAT is defined, the behaviour has
1188 * been fixed. We need not care about any keys here, since
1189 * there are ioctls that deal with the lock key / LED stuff.
1195 #if PCVT_FREEBSD > 210
1196 add_keyboard_randomness(dt);
1197 #endif /* PCVT_FREEBSD > 210 */
1199 #if !PCVT_USL_VT_COMPAT
1200 if ((dt & 0x80) == 0)
1205 /* XXX on which virt screen? */ vsp->num_lock ^= 1;
1210 vsp->caps_lock ^= 1;
1215 vsp->scroll_lock ^= 1;
1219 #endif /* !PCVT_USL_VT_COMPAT */
1223 * The (mouse systems) mouse emulator. The mouse
1224 * device allocates the first device node that is
1225 * not used by a virtual terminal. (E.g., you have
1226 * eight vtys, /dev/ttyv0 thru /dev/ttyv7, so the
1227 * mouse emulator were /dev/ttyv8.)
1228 * Currently the emulator only works if the keyboard
1229 * is in raw (PC scan code) mode. This is the typic-
1230 * al case when running the X server.
1231 * It is activated if the num locks LED is active
1232 * for the current vty, and if the mouse device
1233 * has been opened by at least one process. It
1234 * grabs the numerical keypad events (but only
1235 * the "non-extended", so the separate arrow keys
1236 * continue to work), and three keys for the "mouse
1237 * buttons", preferrably F1 thru F3. Any of the
1238 * eight directions (N, NE, E, SE, S, SW, W, NW)
1239 * is supported, and frequent key presses (less
1240 * than e.g. half a second between key presses)
1241 * cause the emulator to accelerate the pointer
1242 * movement by 6, while single presses result in
1243 * single moves, so each point can be reached.
1246 * NB: the following code is spagghetti.
1247 * Only eat it with lotta tomato ketchup and
1248 * Parmesan cheese:-)
1251 * look whether we will have to steal the keys
1252 * and cook them into mouse events
1254 if(vsp->num_lock && mouse.opened)
1256 int button, accel, i;
1259 MOUSE_NW, MOUSE_N, MOUSE_NE,
1260 MOUSE_W, MOUSE_0, MOUSE_E,
1261 MOUSE_SW, MOUSE_S, MOUSE_SE
1265 dev_t dummy = makedev(0, mouse.minor);
1266 struct tty *mousetty = get_pccons(dummy);
1268 * strings to send for each mouse event,
1269 * indexed by the movement direction and
1270 * the "accelerator" value (TRUE for frequent
1271 * key presses); note that the first byte
1272 * of each string is actually overwritten
1273 * by the current button value before sending
1276 static u_char mousestrings[2][MOUSE_SE+1][5] =
1279 /* first, the non-accelerated strings*/
1280 {0x87, -1, 1, 0, 0}, /* NW */
1281 {0x87, 0, 1, 0, 0}, /* N */
1282 {0x87, 1, 1, 0, 0}, /* NE */
1283 {0x87, -1, 0, 0, 0}, /* W */
1284 {0x87, 0, 0, 0, 0}, /* 0 */
1285 {0x87, 1, 0, 0, 0}, /* E */
1286 {0x87, -1, -1, 0, 0}, /* SW */
1287 {0x87, 0, -1, 0, 0}, /* S */
1288 {0x87, 1, -1, 0, 0} /* SE */
1291 /* now, 6 steps at once */
1292 {0x87, -4, 4, 0, 0}, /* NW */
1293 {0x87, 0, 6, 0, 0}, /* N */
1294 {0x87, 4, 4, 0, 0}, /* NE */
1295 {0x87, -6, 0, 0, 0}, /* W */
1296 {0x87, 0, 0, 0, 0}, /* 0 */
1297 {0x87, 6, 0, 0, 0}, /* E */
1298 {0x87, -4, -4, 0, 0}, /* SW */
1299 {0x87, 0, -6, 0, 0}, /* S */
1300 {0x87, 4, -4, 0, 0} /* SE */
1306 /* ignore extended scan codes */
1307 mouse.extendedseen = 1;
1308 goto no_mouse_event;
1310 if(mouse.extendedseen)
1312 mouse.extendedseen = 0;
1313 goto no_mouse_event;
1315 mouse.extendedseen = 0;
1318 * Note that we cannot use a switch here
1319 * since we want to have the keycodes in
1322 if((dt & 0x7f) == mousedef.leftbutton) {
1326 else if((dt & 0x7f) == mousedef.middlebutton) {
1330 else if((dt & 0x7f) == mousedef.rightbutton) {
1335 * i would really like to give
1336 * some acustical support
1337 * (pling/plong); i am not sure
1338 * whether it is safe to call
1339 * sysbeep from within an intr
1340 * service, since it calls
1341 * timeout in turn which mani-
1342 * pulates the spl mask - jw
1345 # define PLING sysbeep(PCVT_SYSBEEPF / 1500, 2)
1346 # define PLONG sysbeep(PCVT_SYSBEEPF / 1200, 2)
1348 if(mousedef.stickybuttons)
1351 mouse.breakseen = 1;
1354 else if(mouse.buttons == button
1355 && !mouse.breakseen) {
1356 /* ignore repeats */
1360 mouse.breakseen = 0;
1361 if(mouse.buttons == button) {
1367 * eventually, release
1369 * and stick this one
1371 mouse.buttons = button;
1382 else if((mouse.buttons
1388 /*else: ignore same btn press*/
1395 else switch(dt & 0x7f)
1397 /* the arrow keys - KP 1 thru KP 9 */
1398 case 0x47: move = MOUSE_NW; goto do_move;
1399 case 0x48: move = MOUSE_N; goto do_move;
1400 case 0x49: move = MOUSE_NE; goto do_move;
1401 case 0x4b: move = MOUSE_W; goto do_move;
1402 case 0x4c: move = MOUSE_0; goto do_move;
1403 case 0x4d: move = MOUSE_E; goto do_move;
1404 case 0x4f: move = MOUSE_SW; goto do_move;
1405 case 0x50: move = MOUSE_S; goto do_move;
1406 case 0x51: move = MOUSE_SE;
1410 * arrow key break events are
1411 * of no importance for us
1415 * see whether the last move did
1416 * happen "recently", i.e. before
1417 * less than half a second
1420 timevalsub(&now, &mouse.lastmove);
1421 getmicrotime(&mouse.lastmove);
1422 accel = (now.tv_sec == 0
1424 < mousedef.acceltime);
1427 default: /* not a mouse-emulating key */
1428 goto no_mouse_event;
1430 mousestrings[accel][move][0] =
1431 0x80 + (~mouse.buttons & 7);
1432 /* finally, send the string */
1433 for(i = 0; i < 5; i++)
1434 (*linesw[mousetty->t_line].l_rint)
1435 (mousestrings[accel][move][i],
1437 return (u_char *)0; /* not a kbd event */
1441 #endif /* PCVT_EMU_MOUSE */
1443 return ((u_char *)keybuf);
1447 #else /* !XSERVER */
1449 #ifndef _DEV_KBD_KBDREG_H_
1453 /* see if there is data from the keyboard available either from */
1454 /* the keyboard fifo or from the 8042 keyboard controller */
1456 if (pcvt_kbd_count || (inb(CONTROLLER_CTRL) & STATUS_OUTPBF))
1458 if (!noblock || kbd_polling) /* source = 8042 */
1460 PCVT_KBD_DELAY(); /* 7 us delay */
1461 dt = inb(CONTROLLER_DATA);
1463 else /* source = keyboard fifo */
1465 dt = pcvt_kbd_fifo[pcvt_kbd_rptr++]; /* yes, get it ! */
1466 PCVT_DISABLE_INTR();
1469 if (pcvt_kbd_rptr >= PCVT_KBD_FIFO_SZ)
1474 #else /* !PCVT_KBD_FIFO */
1476 /* see if there is data from the keyboard available from the 8042 */
1478 if(inb(CONTROLLER_CTRL) & STATUS_OUTPBF)
1480 PCVT_KBD_DELAY(); /* 7 us delay */
1481 dt = inb(CONTROLLER_DATA); /* yes, get data ! */
1484 #endif /* !PCVT_KBD_FIFO */
1486 #else /* _DEV_KBD_KBDREG_H_ */
1489 if (pcvt_kbd_count) {
1490 dt = pcvt_kbd_fifo[pcvt_kbd_rptr++];
1491 PCVT_DISABLE_INTR();
1494 if (pcvt_kbd_rptr >= PCVT_KBD_FIFO_SZ)
1497 #endif /* PCVT_KBD_FIFO */
1499 while ((c = (*kbdsw[kbd->kb_index]->read)(kbd, TRUE)) == -1)
1503 if ((c = (*kbdsw[kbd->kb_index]->read)(kbd, FALSE)) == -1)
1508 #endif /* !_DEV_KBD_KBDREG_H_ */
1510 #endif /* !XSERVER */
1512 #ifndef _DEV_KBD_KBDREG_H_
1520 #endif /* !_DEV_KBD_KBDREG_H_ */
1524 #endif /* PCVT_SHOWKEYS */
1526 /* lets look what we got */
1529 case KEYB_R_OVERRUN0: /* keyboard buffer overflow */
1531 #if PCVT_SCANSET == 2
1532 case KEYB_R_SELFOK: /* keyboard selftest ok */
1533 #endif /* PCVT_SCANSET == 2 */
1535 case KEYB_R_ECHO: /* keyboard response to KEYB_C_ECHO */
1536 case KEYB_R_ACK: /* acknowledge after command has rx'd*/
1537 case KEYB_R_SELFBAD: /* keyboard selftest FAILED */
1538 case KEYB_R_DIAGBAD: /* keyboard self diagnostic failure */
1539 case KEYB_R_RESEND: /* keyboard wants us to resend cmnd */
1540 case KEYB_R_OVERRUN1: /* keyboard buffer overflow */
1543 case KEYB_R_EXT1: /* keyboard extended scancode pfx 2 */
1544 kbd_status.ext1 = 1;
1546 case KEYB_R_EXT0: /* keyboard extended scancode pfx 1 */
1547 kbd_status.extended = 1;
1550 #if PCVT_SCANSET == 2
1551 case KEYB_R_BREAKPFX: /* break code prefix for set 2 and 3 */
1552 kbd_status.breakseen = 1;
1554 #endif /* PCVT_SCANSET == 2 */
1557 goto regular; /* regular key */
1565 /* got a normal scan key */
1568 #if PCVT_FREEBSD > 210
1569 add_keyboard_randomness(dt);
1570 #endif /* PCVT_FREEBSD > 210 */
1572 #if PCVT_SCANSET == 1
1573 kbd_status.breakseen = dt & 0x80 ? 1 : 0;
1575 #endif /* PCVT_SCANSET == 1 */
1577 /* make a keycode from scan code */
1578 if(dt >= sizeof scantokey / sizeof(u_char))
1581 key = kbd_status.extended ? extscantokey[dt] : scantokey[dt];
1583 if(kbd_status.ext1 && key == 64)
1584 /* virtual control key */
1587 kbd_status.extended = kbd_status.ext1 = 0;
1589 if ((key == 85) && shift_down && kbd_lastkey != 85)
1591 if (vsp->scr_offset > (vsp->screen_rows - 1))
1593 if (!vsp->scrolling)
1595 vsp->scrolling += vsp->screen_rows - 2;
1596 if (vsp->Scrollback)
1598 scrollback_save_screen();
1599 if (vsp->scr_offset == vsp->max_off)
1601 bcopy(vsp->Scrollback +
1605 vsp->max_off * CHR);
1608 bcopy(vsp->Crtat + vsp->cur_offset -
1609 vsp->col, vsp->Scrollback +
1610 ((vsp->scr_offset + 1) *
1611 vsp->maxcol), vsp->maxcol * CHR);
1618 vsp->scrolling += vsp->screen_rows - 1;
1620 if (vsp->scrolling > vsp->scr_offset)
1621 vsp->scrolling = vsp->scr_offset;
1623 bcopy(vsp->Scrollback + ((vsp->scr_offset -
1624 vsp->scrolling) * vsp->maxcol), vsp->Crtat,
1625 vsp->screen_rows * vsp->maxcol * CHR);
1631 else if ((key == 86) && shift_down && kbd_lastkey != 86)
1635 if (vsp->scrolling > 0)
1637 vsp->scrolling -= vsp->screen_rows - 1;
1638 if (vsp->scrolling < 0)
1641 if (vsp->scrolling <= vsp->screen_rows)
1644 scrollback_restore_screen();
1648 bcopy(vsp->Scrollback + ((vsp->scr_offset -
1649 vsp->scrolling) * vsp->maxcol),
1650 vsp->Crtat, vsp->screen_rows *
1655 if (vsp->scrolling == 0)
1663 if (noblock == 31337)
1676 else if (vsp->scrolling && key != 128 && key != 44 && key != 85 &&
1683 #if PCVT_CTRL_ALT_DEL /* Check for cntl-alt-del */
1684 if((key == 76) && ctrl_down && (meta_down||altgr_down))
1686 #endif /* PCVT_CTRL_ALT_DEL */
1688 #if !(PCVT_NETBSD || PCVT_FREEBSD >= 200)
1690 #endif /* !(PCVT_NETBSD || PCVT_FREEBSD >= 200) */
1692 #if NDDB > 0 || defined(DDB) /* Check for cntl-alt-esc */
1694 if((key == 110) && ctrl_down && (meta_down || altgr_down))
1696 static u_char in_Debugger;
1702 /* the string is actually not used... */
1714 #endif /* NDDB > 0 || defined(DDB) */
1716 /* look for keys with special handling */
1720 * virtual shift; sent around PrtScr, and around the arrow
1721 * keys if the NumLck LED is on
1723 kbd_status.vshift = !kbd_status.breakseen;
1724 key = 0; /* no key */
1729 * virtual control - the most ugly thingie at all
1730 * the Pause key sends:
1731 * <virtual control make> <numlock make> <virtual control
1732 * break> <numlock break>
1734 if(!kbd_status.breakseen)
1735 kbd_status.vcontrol = 1;
1736 /* else: let the numlock hook clear this */
1737 key = 0; /* no key */
1741 /* NumLock, look whether this is rather a Pause */
1742 if(kbd_status.vcontrol)
1745 * if this is the final break code of a Pause key,
1746 * clear the virtual control status, too
1748 if(kbd_status.vcontrol && kbd_status.breakseen)
1749 kbd_status.vcontrol = 0;
1754 * a SysRq; some keyboards are brain-dead enough to
1755 * repeat the SysRq key make code by sending PrtScr
1756 * make codes; other keyboards do not repeat SysRq
1757 * at all. We keep track of the SysRq state here.
1759 kbd_status.sysrq = !kbd_status.breakseen;
1764 * PrtScr; look whether this is really PrtScr or rather
1765 * a silly repeat of a SysRq key
1767 if(kbd_status.sysrq)
1768 /* ignore the garbage */
1772 /* in NOREPEAT MODE ignore the key if it was the same as before */
1774 if(!kbrepflag && key == kbd_lastkey && !kbd_status.breakseen)
1782 type = key2ascii[key].type;
1784 if(type & KBD_OVERLOAD)
1785 type = ovltbl[key2ascii[key].ovlindex].type;
1792 if(!kbd_status.breakseen && key != kbd_lastkey)
1794 vsp->shift_lock ^= 1;
1799 if(!kbd_status.breakseen && key != kbd_lastkey)
1801 vsp->caps_lock ^= 1;
1807 if(!kbd_status.breakseen && key != kbd_lastkey)
1809 vsp->scroll_lock ^= 1;
1812 if(!(vsp->scroll_lock))
1814 /* someone may be sleeping */
1815 wakeup((caddr_t)&(vsp->scroll_lock));
1821 shift_down = kbd_status.breakseen ? 0 : 1;
1825 meta_down = kbd_status.breakseen ? 0 : 0x80;
1829 altgr_down = kbd_status.breakseen ? 0 : 1;
1833 ctrl_down = kbd_status.breakseen ? 0 : 1;
1838 break; /* deliver a key */
1841 if(kbd_status.breakseen)
1844 kbd_status.breakseen = 0;
1845 kbd_lastkey = 0; /* -hv- I know this is a bug with */
1846 } /* N-Key-Rollover, but I ignore that */
1847 else /* because avoidance is too complicated */
1850 cp = xlatkey2ascii(key); /* have a key */
1852 if(cp == NULL && !noblock)
1858 /*---------------------------------------------------------------------------*
1859 * reflect status of locking keys & set led's
1860 *---------------------------------------------------------------------------*/
1862 setlockkeys(int snc)
1864 vsp->scroll_lock = snc & 1;
1865 vsp->num_lock = (snc & 2) ? 1 : 0;
1866 vsp->caps_lock = (snc & 4) ? 1 : 0;
1870 /*---------------------------------------------------------------------------*
1871 * remove a key definition
1872 *---------------------------------------------------------------------------*/
1876 register Ovl_tbl *ref;
1878 if(key==0 || key > MAXKEYNUM)
1881 if(key2ascii[key].type & KBD_OVERLOAD)
1883 ref = &ovltbl[key2ascii[key].ovlindex];
1890 key2ascii[key].type &= KBD_MASK;
1895 /*---------------------------------------------------------------------------*
1897 *---------------------------------------------------------------------------*/
1899 setkeydef(Ovl_tbl *data)
1903 if( data->keynum > MAXKEYNUM ||
1904 (data->type & KBD_MASK) == KBD_BREAK ||
1905 (data->type & KBD_MASK) > KBD_SHFTLOCK)
1908 data->unshift[KBDMAXOVLKEYSIZE] =
1909 data->shift[KBDMAXOVLKEYSIZE] =
1910 data->ctrl[KBDMAXOVLKEYSIZE] =
1911 data->altgr[KBDMAXOVLKEYSIZE] = 0;
1916 data->suba = KBD_SUBT_STR; /* just strings .. */
1918 data->type |= KBD_OVERLOAD; /* mark overloaded */
1920 /* if key already overloaded, use that slot else find free slot */
1922 if(key2ascii[data->keynum].type & KBD_OVERLOAD)
1924 i = key2ascii[data->keynum].ovlindex;
1928 for(i=0; i<OVLTBL_SIZE; i++)
1929 if(ovltbl[i].keynum==0)
1933 return ENOSPC; /* no space, abuse of ENOSPC(!) */
1936 ovltbl[i] = *data; /* copy new data string */
1938 key2ascii[data->keynum].type |= KBD_OVERLOAD; /* mark key */
1939 key2ascii[data->keynum].ovlindex = i;
1944 /*---------------------------------------------------------------------------*
1945 * keyboard ioctl's entry
1946 *---------------------------------------------------------------------------*/
1948 kbdioctl(Dev_t dev, int cmd, caddr_t data, int flag)
1957 settpmrate(KBD_TPD500|KBD_TPM100);
1962 *(int *)data = tpmrate;
1966 settpmrate(*(int *)data);
1970 *(int *)data = kbrepflag;
1974 kbrepflag = (*(int *)data) & 1;
1978 *(int *)data = ledstate;
1982 update_led(); /* ? */
1986 *(int *)data = ( (vsp->scroll_lock) |
1987 (vsp->num_lock * 2) |
1988 (vsp->caps_lock * 4));
1992 setlockkeys(*(int *)data);
1996 key = ((Ovl_tbl *)data)->keynum;
1997 return getckeydef(key,(Ovl_tbl *)data);
2000 key = ((Ovl_tbl *)data)->keynum;
2001 return setkeydef((Ovl_tbl *)data);
2004 key = ((Ovl_tbl *)data)->keynum;
2005 return getokeydef(key,(Ovl_tbl *)data);
2009 return rmkeydef(key);
2016 /* proceed with vga ioctls */
2023 /*--------------------------------------------------------------------------*
2024 * mouse emulator ioctl
2025 *--------------------------------------------------------------------------*/
2027 mouse_ioctl(Dev_t dev, int cmd, caddr_t data)
2029 struct mousedefs *def = (struct mousedefs *)data;
2046 #endif /* PCVT_EMU_MOUSE */
2048 #if PCVT_USL_VT_COMPAT
2049 /*---------------------------------------------------------------------------*
2050 * convert ISO-8859 style keycode into IBM 437
2051 *---------------------------------------------------------------------------*/
2052 static __inline u_char
2057 return iso2ibm437[c - 0x80];
2060 /*---------------------------------------------------------------------------*
2061 * build up a USL style keyboard map
2062 *---------------------------------------------------------------------------*/
2064 get_usl_keymap(keymap_t *map)
2068 bzero((caddr_t)map, sizeof(keymap_t));
2070 map->n_keys = 0x59; /* that many keys we know about */
2072 for(i = 1; i < N_KEYNUMS; i++)
2077 int idx = key2scan1[i];
2079 if(idx == 0 || idx >= map->n_keys)
2082 getckeydef(i, &kdef);
2083 kdef.type &= KBD_MASK;
2088 map->key[idx].map[0] = iso2ibm(kdef.unshift[0]);
2089 map->key[idx].map[1] = iso2ibm(kdef.shift[0]);
2090 map->key[idx].map[2] = map->key[idx].map[3] =
2091 iso2ibm(kdef.ctrl[0]);
2092 map->key[idx].map[4] = map->key[idx].map[5] =
2093 iso2ibm(c = kdef.altgr[0]);
2095 * XXX this is a hack
2096 * since we currently do not map strings to AltGr +
2097 * shift, we attempt to use the unshifted AltGr
2098 * definition here and try to toggle the case
2099 * this should at least work for ISO8859 letters,
2100 * but also for (e.g.) russian KOI-8 style
2102 if((c & 0x7f) >= 0x40)
2103 map->key[idx].map[5] = iso2ibm(c ^ 0x20);
2107 /* we are only interested in F1 thru F12 here */
2108 if(i >= 112 && i <= 123) {
2109 map->key[idx].map[0] = i - 112 + 27;
2110 map->key[idx].spcl = 0x80;
2115 c = i == 44? 2 /* lSh */: 3 /* rSh */; goto special;
2118 c = 4; goto special;
2121 c = 5; goto special;
2124 c = 6; goto special;
2127 c = 7; goto special;
2130 c = 9; goto special;
2132 for(j = 0; j < NUM_STATES; j++)
2133 map->key[idx].map[j] = c;
2134 map->key[idx].spcl = 0xff;
2143 #endif /* PCVT_USL_VT_COMPAT */
2145 /*---------------------------------------------------------------------------*
2146 * switch keypad to numeric mode
2147 *---------------------------------------------------------------------------*/
2149 vt_keynum(struct video_state *svsp)
2155 /*---------------------------------------------------------------------------*
2156 * switch keypad to application mode
2157 *---------------------------------------------------------------------------*/
2159 vt_keyappl(struct video_state *svsp)
2165 #if !PCVT_VT220KEYB /* !PCVT_VT220KEYB, HP-like Keyboard layout */
2167 /*---------------------------------------------------------------------------*
2168 * function bound to function key 1
2169 *---------------------------------------------------------------------------*/
2175 if((vsp->vt_pure_mode == M_HPVT)
2176 && (vsp->which_fkl == SYS_FKL))
2179 more_chars = (u_char *)"\033[17~"; /* F6 */
2183 if(vsp->vt_pure_mode == M_PUREVT
2184 || (vsp->which_fkl == USR_FKL))
2185 more_chars = (u_char *)"\033[26~"; /* F14 */
2189 /*---------------------------------------------------------------------------*
2190 * function bound to function key 2
2191 *---------------------------------------------------------------------------*/
2197 if((vsp->vt_pure_mode == M_HPVT)
2198 && (vsp->which_fkl == SYS_FKL))
2201 more_chars = (u_char *)"\033[18~"; /* F7 */
2205 if(vsp->vt_pure_mode == M_PUREVT
2206 || (vsp->which_fkl == USR_FKL))
2207 more_chars = (u_char *)"\033[28~"; /* HELP */
2211 /*---------------------------------------------------------------------------*
2212 * function bound to function key 3
2213 *---------------------------------------------------------------------------*/
2219 if((vsp->vt_pure_mode == M_HPVT)
2220 && (vsp->which_fkl == SYS_FKL))
2223 more_chars = (u_char *)"\033[19~"; /* F8 */
2227 if(vsp->vt_pure_mode == M_PUREVT
2228 || (vsp->which_fkl == USR_FKL))
2229 more_chars = (u_char *)"\033[29~"; /* DO */
2233 /*---------------------------------------------------------------------------*
2234 * function bound to function key 4
2235 *---------------------------------------------------------------------------*/
2243 if((vsp->vt_pure_mode == M_HPVT)
2244 && (vsp->which_fkl == SYS_FKL))
2247 more_chars = (u_char *)"\033[20~"; /* F9 */
2249 if(vsp->vt_pure_mode == M_PUREVT
2250 || (vsp->which_fkl == USR_FKL))
2251 more_chars = (u_char *)"\033[20~"; /* F9 */
2252 #endif /* PCVT_SHOWKEYS */
2257 if(vsp->vt_pure_mode == M_PUREVT
2258 || (vsp->which_fkl == USR_FKL))
2259 more_chars = (u_char *)"\033[31~"; /* F17 */
2263 /*---------------------------------------------------------------------------*
2264 * function bound to function key 5
2265 *---------------------------------------------------------------------------*/
2271 if((vsp->vt_pure_mode == M_HPVT)
2272 && (vsp->which_fkl == SYS_FKL))
2275 more_chars = (u_char *)"\033[21~"; /* F10 */
2279 if(vsp->vt_pure_mode == M_PUREVT
2280 || (vsp->which_fkl == USR_FKL))
2281 more_chars = (u_char *)"\033[32~"; /* F18 */
2285 /*---------------------------------------------------------------------------*
2286 * function bound to function key 6
2287 *---------------------------------------------------------------------------*/
2293 if((vsp->vt_pure_mode == M_HPVT)
2294 && (vsp->which_fkl == SYS_FKL))
2295 toggl_sevenbit(vsp);
2297 more_chars = (u_char *)"\033[23~"; /* F11 */
2301 if(vsp->vt_pure_mode == M_PUREVT
2302 || (vsp->which_fkl == USR_FKL))
2303 more_chars = (u_char *)"\033[33~"; /* F19 */
2307 /*---------------------------------------------------------------------------*
2308 * function bound to function key 7
2309 *---------------------------------------------------------------------------*/
2315 if((vsp->vt_pure_mode == M_HPVT)
2316 && (vsp->which_fkl == SYS_FKL))
2319 more_chars = (u_char *)"\033[24~"; /* F12 */
2323 if(vsp->vt_pure_mode == M_PUREVT
2324 || (vsp->which_fkl == USR_FKL))
2325 more_chars = (u_char *)"\033[34~"; /* F20 */
2329 /*---------------------------------------------------------------------------*
2330 * function bound to function key 8
2331 *---------------------------------------------------------------------------*/
2337 if((vsp->vt_pure_mode == M_HPVT)
2338 && (vsp->which_fkl == SYS_FKL))
2341 more_chars = (u_char *)"\033[25~"; /* F13 */
2345 if(vsp->vt_pure_mode == M_PUREVT
2346 || (vsp->which_fkl == USR_FKL))
2347 more_chars = (u_char *)"\033[35~"; /* F21 ? !! */
2351 /*---------------------------------------------------------------------------*
2352 * function bound to function key 9
2353 *---------------------------------------------------------------------------*/
2359 if(vsp->vt_pure_mode == M_PUREVT)
2362 if(vsp->labels_on) /* toggle label display on/off */
2373 /*---------------------------------------------------------------------------*
2374 * function bound to function key 10
2375 *---------------------------------------------------------------------------*/
2381 if(vsp->vt_pure_mode != M_PUREVT && vsp->labels_on)
2383 if(vsp->which_fkl == USR_FKL)
2385 else if(vsp->which_fkl == SYS_FKL)
2395 /*---------------------------------------------------------------------------*
2396 * function bound to function key 11
2397 *---------------------------------------------------------------------------*/
2403 if(vsp->vt_pure_mode == M_PUREVT)
2404 set_emulation_mode(vsp, M_HPVT);
2405 else if(vsp->vt_pure_mode == M_HPVT)
2406 set_emulation_mode(vsp, M_PUREVT);
2414 /*---------------------------------------------------------------------------*
2415 * function bound to function key 12
2416 *---------------------------------------------------------------------------*/
2422 if(current_video_screen + 1 > totalscreens-1)
2425 do_vgapage(current_video_screen + 1);
2433 /*---------------------------------------------------------------------------*
2434 * function bound to SHIFTED function key 1
2435 *---------------------------------------------------------------------------*/
2441 if(vsp->ukt.length[0]) /* entry available ? */
2442 more_chars = (u_char *)
2443 &(vsp->udkbuf[vsp->ukt.first[0]]);
2447 if(vsp->ukt.length[9]) /* entry available ? */
2448 more_chars = (u_char *)
2449 &(vsp->udkbuf[vsp->ukt.first[9]]);
2453 /*---------------------------------------------------------------------------*
2454 * function bound to SHIFTED function key 2
2455 *---------------------------------------------------------------------------*/
2461 if(vsp->ukt.length[1]) /* entry available ? */
2462 more_chars = (u_char *)
2463 &(vsp->udkbuf[vsp->ukt.first[1]]);
2467 if(vsp->ukt.length[11]) /* entry available ? */
2468 more_chars = (u_char *)
2469 &(vsp->udkbuf[vsp->ukt.first[11]]);
2473 /*---------------------------------------------------------------------------*
2474 * function bound to SHIFTED function key 3
2475 *---------------------------------------------------------------------------*/
2481 if(vsp->ukt.length[2]) /* entry available ? */
2482 more_chars = (u_char *)
2483 &(vsp->udkbuf[vsp->ukt.first[2]]);
2487 if(vsp->ukt.length[12]) /* entry available ? */
2488 more_chars = (u_char *)
2489 &(vsp->udkbuf[vsp->ukt.first[12]]);
2493 /*---------------------------------------------------------------------------*
2494 * function bound to SHIFTED function key 4
2495 *---------------------------------------------------------------------------*/
2501 if(vsp->ukt.length[3]) /* entry available ? */
2502 more_chars = (u_char *)
2503 &(vsp->udkbuf[vsp->ukt.first[3]]);
2507 if(vsp->ukt.length[13]) /* entry available ? */
2508 more_chars = (u_char *)
2509 &(vsp->udkbuf[vsp->ukt.first[13]]);
2513 /*---------------------------------------------------------------------------*
2514 * function bound to SHIFTED function key 5
2515 *---------------------------------------------------------------------------*/
2521 if(vsp->ukt.length[4]) /* entry available ? */
2522 more_chars = (u_char *)
2523 &(vsp->udkbuf[vsp->ukt.first[4]]);
2527 if(vsp->ukt.length[14]) /* entry available ? */
2528 more_chars = (u_char *)
2529 &(vsp->udkbuf[vsp->ukt.first[14]]);
2533 /*---------------------------------------------------------------------------*
2534 * function bound to SHIFTED function key 6
2535 *---------------------------------------------------------------------------*/
2541 if(vsp->ukt.length[6]) /* entry available ? */
2542 more_chars = (u_char *)
2543 &(vsp->udkbuf[vsp->ukt.first[6]]);
2547 if(vsp->ukt.length[15]) /* entry available ? */
2548 more_chars = (u_char *)
2549 &(vsp->udkbuf[vsp->ukt.first[15]]);
2553 /*---------------------------------------------------------------------------*
2554 * function bound to SHIFTED function key 7
2555 *---------------------------------------------------------------------------*/
2561 if(vsp->ukt.length[7]) /* entry available ? */
2562 more_chars = (u_char *)
2563 &(vsp->udkbuf[vsp->ukt.first[7]]);
2567 if(vsp->ukt.length[16]) /* entry available ? */
2568 more_chars = (u_char *)
2569 &(vsp->udkbuf[vsp->ukt.first[16]]);
2573 /*---------------------------------------------------------------------------*
2574 * function bound to SHIFTED function key 8
2575 *---------------------------------------------------------------------------*/
2581 if(vsp->ukt.length[8]) /* entry available ? */
2582 more_chars = (u_char *)
2583 &(vsp->udkbuf[vsp->ukt.first[8]]);
2587 if(vsp->ukt.length[17]) /* entry available ? */
2588 more_chars = (u_char *)
2589 &(vsp->udkbuf[vsp->ukt.first[17]]);
2592 /*---------------------------------------------------------------------------*
2593 * function bound to SHIFTED function key 9
2594 *---------------------------------------------------------------------------*/
2600 /*---------------------------------------------------------------------------*
2601 * function bound to SHIFTED function key 10
2602 *---------------------------------------------------------------------------*/
2608 /*---------------------------------------------------------------------------*
2609 * function bound to SHIFTED function key 11
2610 *---------------------------------------------------------------------------*/
2616 /*---------------------------------------------------------------------------*
2617 * function bound to SHIFTED function key 12
2618 *---------------------------------------------------------------------------*/
2624 /*---------------------------------------------------------------------------*
2625 * function bound to control function key 1
2626 *---------------------------------------------------------------------------*/
2634 /*---------------------------------------------------------------------------*
2635 * function bound to control function key 2
2636 *---------------------------------------------------------------------------*/
2644 /*---------------------------------------------------------------------------*
2645 * function bound to control function key 3
2646 *---------------------------------------------------------------------------*/
2654 /*---------------------------------------------------------------------------*
2655 * function bound to control function key 4
2656 *---------------------------------------------------------------------------*/
2664 /*---------------------------------------------------------------------------*
2665 * function bound to control function key 5
2666 *---------------------------------------------------------------------------*/
2674 /*---------------------------------------------------------------------------*
2675 * function bound to control function key 6
2676 *---------------------------------------------------------------------------*/
2684 /*---------------------------------------------------------------------------*
2685 * function bound to control function key 7
2686 *---------------------------------------------------------------------------*/
2694 /*---------------------------------------------------------------------------*
2695 * function bound to control function key 8
2696 *---------------------------------------------------------------------------*/
2704 /*---------------------------------------------------------------------------*
2705 * function bound to control function key 9
2706 *---------------------------------------------------------------------------*/
2714 /*---------------------------------------------------------------------------*
2715 * function bound to control function key 10
2716 *---------------------------------------------------------------------------*/
2724 /*---------------------------------------------------------------------------*
2725 * function bound to control function key 11
2726 *---------------------------------------------------------------------------*/
2734 /*---------------------------------------------------------------------------*
2735 * function bound to control function key 12
2736 *---------------------------------------------------------------------------*/
2744 #else /* PCVT_VT220 - VT220-like Keyboard layout */
2746 /*---------------------------------------------------------------------------*
2747 * function bound to function key 1
2748 *---------------------------------------------------------------------------*/
2753 more_chars = (u_char *)"\033[23~"; /* F11 */
2758 /*---------------------------------------------------------------------------*
2759 * function bound to function key 2
2760 *---------------------------------------------------------------------------*/
2765 more_chars = (u_char *)"\033[24~"; /* F12 */
2770 /*---------------------------------------------------------------------------*
2771 * function bound to function key 3
2772 *---------------------------------------------------------------------------*/
2777 more_chars = (u_char *)"\033[25~"; /* F13 */
2782 /*---------------------------------------------------------------------------*
2783 * function bound to function key 4
2784 *---------------------------------------------------------------------------*/
2789 more_chars = (u_char *)"\033[26~"; /* F14 */
2794 /*---------------------------------------------------------------------------*
2795 * function bound to function key 5
2796 *---------------------------------------------------------------------------*/
2801 more_chars = (u_char *)"\033[28~"; /* Help */
2804 if((current_video_screen + 1) > totalscreens-1)
2807 do_vgapage(current_video_screen + 1);
2811 /*---------------------------------------------------------------------------*
2812 * function bound to function key 6
2813 *---------------------------------------------------------------------------*/
2818 more_chars = (u_char *)"\033[29~"; /* DO */
2820 more_chars = (u_char *)"\033[17~"; /* F6 */
2823 /*---------------------------------------------------------------------------*
2824 * function bound to function key 7
2825 *---------------------------------------------------------------------------*/
2830 more_chars = (u_char *)"\033[31~"; /* F17 */
2832 more_chars = (u_char *)"\033[18~"; /* F7 */
2835 /*---------------------------------------------------------------------------*
2836 * function bound to function key 8
2837 *---------------------------------------------------------------------------*/
2842 more_chars = (u_char *)"\033[32~"; /* F18 */
2844 more_chars = (u_char *)"\033[19~"; /* F8 */
2847 /*---------------------------------------------------------------------------*
2848 * function bound to function key 9
2849 *---------------------------------------------------------------------------*/
2854 more_chars = (u_char *)"\033[33~"; /* F19 */
2856 more_chars = (u_char *)"\033[20~"; /* F9 */
2859 /*---------------------------------------------------------------------------*
2860 * function bound to function key 10
2861 *---------------------------------------------------------------------------*/
2866 more_chars = (u_char *)"\033[34~"; /* F20 */
2868 more_chars = (u_char *)"\033[21~"; /* F10 */
2871 /*---------------------------------------------------------------------------*
2872 * function bound to function key 11
2873 *---------------------------------------------------------------------------*/
2878 more_chars = (u_char *)"\0x8FP"; /* PF1 */
2880 more_chars = (u_char *)"\033[23~"; /* F11 */
2883 /*---------------------------------------------------------------------------*
2884 * function bound to function key 12
2885 *---------------------------------------------------------------------------*/
2890 more_chars = (u_char *)"\0x8FQ"; /* PF2 */
2892 more_chars = (u_char *)"\033[24~"; /* F12 */
2895 /*---------------------------------------------------------------------------*
2896 * function bound to SHIFTED function key 1
2897 *---------------------------------------------------------------------------*/
2903 if(vsp->ukt.length[6]) /* entry available ? */
2904 more_chars = (u_char *)
2905 &(vsp->udkbuf[vsp->ukt.first[6]]);
2907 more_chars = (u_char *)"\033[23~"; /* F11 */
2915 /*---------------------------------------------------------------------------*
2916 * function bound to SHIFTED function key 2
2917 *---------------------------------------------------------------------------*/
2923 if(vsp->ukt.length[7]) /* entry available ? */
2924 more_chars = (u_char *)
2925 &(vsp->udkbuf[vsp->ukt.first[7]]);
2927 more_chars = (u_char *)"\033[24~"; /* F12 */
2935 /*---------------------------------------------------------------------------*
2936 * function bound to SHIFTED function key 3
2937 *---------------------------------------------------------------------------*/
2943 if(vsp->ukt.length[8]) /* entry available ? */
2944 more_chars = (u_char *)
2945 &(vsp->udkbuf[vsp->ukt.first[8]]);
2947 more_chars = (u_char *)"\033[25~"; /* F13 */
2955 /*---------------------------------------------------------------------------*
2956 * function bound to SHIFTED function key 4
2957 *---------------------------------------------------------------------------*/
2963 if(vsp->ukt.length[9]) /* entry available ? */
2964 more_chars = (u_char *)
2965 &(vsp->udkbuf[vsp->ukt.first[9]]);
2967 more_chars = (u_char *)"\033[26~"; /* F14 */
2975 /*---------------------------------------------------------------------------*
2976 * function bound to SHIFTED function key 5
2977 *---------------------------------------------------------------------------*/
2983 if(vsp->ukt.length[11]) /* entry available ? */
2984 more_chars = (u_char *)
2985 &(vsp->udkbuf[vsp->ukt.first[11]]);
2987 more_chars = (u_char *)"\033[28~"; /* Help */
2991 if(current_video_screen <= 0)
2992 do_vgapage(totalscreens-1);
2994 do_vgapage(current_video_screen - 1);
2998 /*---------------------------------------------------------------------------*
2999 * function bound to SHIFTED function key 6
3000 *---------------------------------------------------------------------------*/
3006 if(vsp->ukt.length[0]) /* entry available ? */
3007 more_chars = (u_char *)
3008 &(vsp->udkbuf[vsp->ukt.first[0]]);
3010 more_chars = (u_char *)"\033[17~"; /* F6 */
3012 else if(vsp->ukt.length[12]) /* entry available ? */
3013 more_chars = (u_char *)
3014 &(vsp->udkbuf[vsp->ukt.first[12]]);
3016 more_chars = (u_char *)"\033[29~"; /* DO */
3019 /*---------------------------------------------------------------------------*
3020 * function bound to SHIFTED function key 7
3021 *---------------------------------------------------------------------------*/
3027 if(vsp->ukt.length[1]) /* entry available ? */
3028 more_chars = (u_char *)
3029 &(vsp->udkbuf[vsp->ukt.first[1]]);
3031 more_chars = (u_char *)"\033[18~"; /* F7 */
3033 else if(vsp->ukt.length[14]) /* entry available ? */
3034 more_chars = (u_char *)
3035 &(vsp->udkbuf[vsp->ukt.first[14]]);
3037 more_chars = (u_char *)"\033[31~"; /* F17 */
3040 /*---------------------------------------------------------------------------*
3041 * function bound to SHIFTED function key 8
3042 *---------------------------------------------------------------------------*/
3048 if(vsp->ukt.length[2]) /* entry available ? */
3049 more_chars = (u_char *)
3050 &(vsp->udkbuf[vsp->ukt.first[2]]);
3052 more_chars = (u_char *)"\033[19~"; /* F8 */
3054 else if(vsp->ukt.length[14]) /* entry available ? */
3055 more_chars = (u_char *)
3056 &(vsp->udkbuf[vsp->ukt.first[15]]);
3058 more_chars = (u_char *)"\033[32~"; /* F18 */
3061 /*---------------------------------------------------------------------------*
3062 * function bound to SHIFTED function key 9
3063 *---------------------------------------------------------------------------*/
3069 if(vsp->ukt.length[3]) /* entry available ? */
3070 more_chars = (u_char *)
3071 &(vsp->udkbuf[vsp->ukt.first[3]]);
3073 more_chars = (u_char *)"\033[20~"; /* F9 */
3075 else if(vsp->ukt.length[16]) /* entry available ? */
3076 more_chars = (u_char *)
3077 &(vsp->udkbuf[vsp->ukt.first[16]]);
3079 more_chars = (u_char *)"\033[33~"; /* F19 */
3082 /*---------------------------------------------------------------------------*
3083 * function bound to SHIFTED function key 10
3084 *---------------------------------------------------------------------------*/
3090 if(vsp->ukt.length[4]) /* entry available ? */
3091 more_chars = (u_char *)
3092 &(vsp->udkbuf[vsp->ukt.first[4]]);
3094 more_chars = (u_char *)"\033[21~"; /* F10 */
3096 else if(vsp->ukt.length[17]) /* entry available ? */
3097 more_chars = (u_char *)
3098 &(vsp->udkbuf[vsp->ukt.first[17]]);
3100 more_chars = (u_char *)"\033[34~"; /* F20 */
3103 /*---------------------------------------------------------------------------*
3104 * function bound to SHIFTED function key 11
3105 *---------------------------------------------------------------------------*/
3111 if(vsp->ukt.length[6]) /* entry available ? */
3112 more_chars = (u_char *)
3113 &(vsp->udkbuf[vsp->ukt.first[6]]);
3115 more_chars = (u_char *)"\033[23~"; /* F11 */
3119 /*---------------------------------------------------------------------------*
3120 * function bound to SHIFTED function key 12
3121 *---------------------------------------------------------------------------*/
3127 if(vsp->ukt.length[7]) /* entry available ? */
3128 more_chars = (u_char *)
3129 &(vsp->udkbuf[vsp->ukt.first[7]]);
3131 more_chars = (u_char *)"\033[24~"; /* F12 */
3135 /*---------------------------------------------------------------------------*
3136 * function bound to control function key 1
3137 *---------------------------------------------------------------------------*/
3141 if(vsp->which_fkl == SYS_FKL)
3145 /*---------------------------------------------------------------------------*
3146 * function bound to control function key 2
3147 *---------------------------------------------------------------------------*/
3151 if(vsp->which_fkl == SYS_FKL)
3155 /*---------------------------------------------------------------------------*
3156 * function bound to control function key 3
3157 *---------------------------------------------------------------------------*/
3161 if(vsp->which_fkl == SYS_FKL)
3165 /*---------------------------------------------------------------------------*
3166 * function bound to control function key 4
3167 *---------------------------------------------------------------------------*/
3173 if(vsp->which_fkl == SYS_FKL)
3175 #endif /* PCVT_SHOWKEYS */
3179 /*---------------------------------------------------------------------------*
3180 * function bound to control function key 5
3181 *---------------------------------------------------------------------------*/
3185 if(vsp->which_fkl == SYS_FKL)
3189 /*---------------------------------------------------------------------------*
3190 * function bound to control function key 6
3191 *---------------------------------------------------------------------------*/
3195 if(vsp->which_fkl == SYS_FKL)
3196 toggl_sevenbit(vsp);
3199 /*---------------------------------------------------------------------------*
3200 * function bound to control function key 7
3201 *---------------------------------------------------------------------------*/
3205 if(vsp->which_fkl == SYS_FKL)
3209 /*---------------------------------------------------------------------------*
3210 * function bound to control function key 8
3211 *---------------------------------------------------------------------------*/
3215 if(vsp->which_fkl == SYS_FKL)
3219 /*---------------------------------------------------------------------------*
3220 * function bound to control function key 9
3221 *---------------------------------------------------------------------------*/
3225 if(vsp->labels_on) /* toggle label display on/off */
3231 /*---------------------------------------------------------------------------*
3232 * function bound to control function key 10
3233 *---------------------------------------------------------------------------*/
3237 if(vsp->labels_on) /* toggle user/system fkey labels */
3239 if(vsp->which_fkl == USR_FKL)
3241 else if(vsp->which_fkl == SYS_FKL)
3246 /*---------------------------------------------------------------------------*
3247 * function bound to control function key 11
3248 *---------------------------------------------------------------------------*/
3252 if(vsp->vt_pure_mode == M_PUREVT)
3253 set_emulation_mode(vsp, M_HPVT);
3254 else if(vsp->vt_pure_mode == M_HPVT)
3255 set_emulation_mode(vsp, M_PUREVT);
3258 /*---------------------------------------------------------------------------*
3259 * function bound to control function key 12
3260 *---------------------------------------------------------------------------*/
3266 #endif /* PCVT_VT220KEYB */
3268 /*---------------------------------------------------------------------------*
3270 *---------------------------------------------------------------------------*/
3272 scrollback_save_screen(void)
3277 s = sizeof(u_short) * vsp->screen_rowsize * vsp->maxcol;
3279 if (scrollback_savedscreen)
3280 free(scrollback_savedscreen, M_TEMP);
3284 if (!(scrollback_savedscreen = (u_short *)malloc(s, M_TEMP, M_NOWAIT)))
3289 bcopy(vsp->Crtat, scrollback_savedscreen, scrnsv_size);
3293 /*---------------------------------------------------------------------------*
3295 *---------------------------------------------------------------------------*/
3297 scrollback_restore_screen(void)
3299 if (scrollback_savedscreen)
3300 bcopy(scrollback_savedscreen, vsp->Crtat, scrnsv_size);
3304 #endif /* NVT > 0 */
3306 /* ------------------------------- EOF -------------------------------------*/