/* * linux/drivers/char/vt.c * * Copyright (C) 1992 obz under the linux copyright * * Dynamic diacritical handling - aeb@cwi.nl - Dec 1993 * Dynamic keymap and string allocation - aeb@cwi.nl - May 1994 * Restrict VT switching via ioctl() - grif@cs.ucr.edu - Dec 1995 * Some code moved for less code duplication - Andi Kleen - Mar 1997 * * * by: Rosimildo da Silva -- * Ported to RTEMS to provide the basic interface to the console * driver. Removed all stuff not required, such as VT_, Fonts, etc. */ #include #include #include #include #include #include /* * Console (vt and kd) routines, as defined by USL SVR4 manual, and by * experimentation and study of X386 SYSV handling. * * One point of difference: SYSV vt's are /dev/vtX, which X >= 0, and * /dev/console is a separate ttyp. Under Linux, /dev/tty0 is /dev/console, * and the vc start at /dev/ttyX, X >= 1. We maintain that here, so we will * always treat our set of vt as numbered 1..MAX_NR_CONSOLES (corresponding to * ttys 0..MAX_NR_CONSOLES-1). Explicitly naming VT 0 is illegal, but using * /dev/tty0 (fg_console) as a target is legal, since an implicit aliasing * to the current console is done by the main ioctl code. */ struct vt_struct *vt_cons[MAX_NR_CONSOLES]; /* Keyboard type: Default is KB_101, but can be set by machine * specific code. */ unsigned char keyboard_type = KB_101; /* * Generates sound of some frequency for some number of clock ticks * * If freq is 0, will turn off sound, else will turn it on for that time. * If msec is 0, will return immediately, else will sleep for msec time, then * turn sound off. * * We also return immediately, which is what was implied within the X * comments - KDMKTONE doesn't put the process to sleep. */ #if defined(__i386__) || defined(__alpha__) || defined(__powerpc__) \ || (defined(__mips__) && !defined(CONFIG_SGI)) static void kd_nosound(unsigned long ignored) { /* disable counter 2 */ outb(inb_p(0x61)&0xFC, 0x61); return; } void _kd_mksound(unsigned int hz, unsigned int ticks) { unsigned int count = 0; int level; if (hz > 20 && hz < 32767) count = 1193180 / hz; _CPU_ISR_Disable(level); /* del_timer(&sound_timer); */ if (count) { /* enable counter 2 */ outb_p(inb_p(0x61)|3, 0x61); /* set command for counter 2, 2 byte write */ outb_p(0xB6, 0x43); /* select desired HZ */ outb_p(count & 0xff, 0x42); outb((count >> 8) & 0xff, 0x42); /* if (ticks) { sound_timer.expires = jiffies+ticks; add_timer(&sound_timer); } */ } else kd_nosound(0); _CPU_ISR_Enable (level); return; } #else void _kd_mksound(unsigned int hz, unsigned int ticks) { } #endif void (*kd_mksound)(unsigned int hz, unsigned int ticks) = _kd_mksound; #define i (tmp.kb_index) #define s (tmp.kb_table) #define v (tmp.kb_value) static inline int do_kdsk_ioctl(int cmd, struct kbentry *user_kbe, int perm, struct kbd_struct *kbd) { struct kbentry tmp; ushort *key_map, val; tmp = *user_kbe; if (i >= NR_KEYS || s >= MAX_NR_KEYMAPS) return -EINVAL; switch (cmd) { case KDGKBENT: key_map = key_maps[s]; if (key_map) { val = U(key_map[i]); if (kbd->kbdmode != VC_UNICODE && KTYP(val) >= NR_TYPES) val = K_HOLE; } else val = (i ? K_HOLE : K_NOSUCHMAP); user_kbe->kb_value = val; return 0; case KDSKBENT: return -EINVAL; } return 0; } #undef i #undef s #undef v #define HZ 100 static inline int do_kbkeycode_ioctl(int cmd, struct kbkeycode *user_kbkc, int perm) { struct kbkeycode tmp; int kc = 0; tmp = *user_kbkc; switch (cmd) { case KDGETKEYCODE: kc = getkeycode(tmp.scancode); if (kc >= 0) user_kbkc->keycode = kc; break; case KDSETKEYCODE: if (!perm) return -EPERM; kc = setkeycode(tmp.scancode, tmp.keycode); break; } return kc; } static inline int do_kdgkb_ioctl(int cmd, struct kbsentry *user_kdgkb, int perm) { return -EINVAL; } /* * We handle the console-specific ioctl's here. We allow the * capability to modify any console, not just the fg_console. */ int vt_ioctl( unsigned int cmd, unsigned long arg) { int perm; unsigned int console; unsigned char ucval; struct kbd_struct * kbd; console = 0; /* * To have permissions to do most of the vt ioctls, we either have * to be the owner of the tty, or super-user. */ perm = 1; kbd = kbd_table + console; switch (cmd) { case KIOCSOUND: if (!perm) return -EPERM; if (arg) arg = 1193180 / arg; kd_mksound(arg, 0); return 0; case KDMKTONE: if (!perm) return -EPERM; { unsigned int ticks, count; /* * Generate the tone for the appropriate number of ticks. * If the time is zero, turn off sound ourselves. */ ticks = HZ * ((arg >> 16) & 0xffff) / 1000; count = ticks ? (arg & 0xffff) : 0; if (count) count = 1193180 / count; kd_mksound(count, ticks); return 0; } case KDGKBTYPE: /* * this is naive. */ ucval = keyboard_type; goto setchar; case KDSETMODE: case KDGETMODE: return -EINVAL; case KDSKBMODE: if (!perm) return -EPERM; switch(arg) { case K_RAW: kbd->kbdmode = VC_RAW; break; case K_MEDIUMRAW: kbd->kbdmode = VC_MEDIUMRAW; break; case K_XLATE: kbd->kbdmode = VC_XLATE; compute_shiftstate(); break; case K_UNICODE: kbd->kbdmode = VC_UNICODE; compute_shiftstate(); break; default: return -EINVAL; } return 0; case KDGKBMODE: ucval = ((kbd->kbdmode == VC_RAW) ? K_RAW : (kbd->kbdmode == VC_MEDIUMRAW) ? K_MEDIUMRAW : (kbd->kbdmode == VC_UNICODE) ? K_UNICODE : K_XLATE); goto setint; /* this could be folded into KDSKBMODE, but for compatibility reasons it is not so easy to fold KDGKBMETA into KDGKBMODE */ case KDSKBMETA: switch(arg) { case K_METABIT: clr_vc_kbd_mode(kbd, VC_META); break; case K_ESCPREFIX: set_vc_kbd_mode(kbd, VC_META); break; default: return -EINVAL; } return 0; case KDGKBMETA: ucval = (vc_kbd_mode(kbd, VC_META) ? K_ESCPREFIX : K_METABIT); setint: *(int *)arg = ucval; return 0; case KDGETKEYCODE: case KDSETKEYCODE: return do_kbkeycode_ioctl(cmd, (struct kbkeycode *)arg, perm); case KDGKBENT: case KDSKBENT: return do_kdsk_ioctl(cmd, (struct kbentry *)arg, perm, kbd); case KDGKBDIACR: { struct kbdiacrs *a = (struct kbdiacrs *)arg; a->kb_cnt = accent_table_size; memcpy( a->kbdiacr, accent_table, accent_table_size*sizeof(struct kbdiacr) ); return 0; } case KDSKBDIACR: { struct kbdiacrs *a = (struct kbdiacrs *)arg; unsigned int ct; if (!perm) return -EPERM; ct = a->kb_cnt; if (ct >= MAX_DIACR) return -EINVAL; accent_table_size = ct; memcpy(accent_table, a->kbdiacr, ct*sizeof(struct kbdiacr)); return 0; } /* the ioctls below read/set the flags usually shown in the leds */ /* don't use them - they will go away without warning */ case KDGKBLED: ucval = kbd->ledflagstate | (kbd->default_ledflagstate << 4); goto setchar; case KDSKBLED: if (!perm) return -EPERM; if (arg & ~0x77) return -EINVAL; kbd->ledflagstate = (arg & 7); kbd->default_ledflagstate = ((arg >> 4) & 7); set_leds(); return 0; /* the ioctls below only set the lights, not the functions */ /* for those, see KDGKBLED and KDSKBLED above */ case KDGETLED: ucval = getledstate(); setchar: *(char*)arg = ucval; return 0; case KDSETLED: if (!perm) return -EPERM; setledstate(kbd, arg); return 0; default: return -EINVAL; } }