This source file includes following definitions.
- kd_nosound
- kd_mksound
- vt_ioctl
1
2
3
4
5
6
7
8 #include <linux/types.h>
9 #include <linux/errno.h>
10 #include <linux/sched.h>
11 #include <linux/tty.h>
12 #include <linux/timer.h>
13 #include <linux/kernel.h>
14 #include <linux/kd.h>
15 #include <linux/vt.h>
16 #include <linux/string.h>
17
18 #include <asm/io.h>
19 #include <asm/segment.h>
20
21 #include "kbd_kern.h"
22 #include "vt_kern.h"
23 #include "diacr.h"
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38 struct vt_struct vt_cons[NR_CONSOLES];
39
40 asmlinkage int sys_ioperm(unsigned long from, unsigned long num, int on);
41
42 extern void compute_shiftstate(void);
43 extern void change_console(unsigned int new_console);
44 extern void complete_change_console(unsigned int new_console);
45 extern int vt_waitactive(void);
46
47
48
49
50 extern int con_set_trans(char * table);
51 extern int con_get_trans(char * table);
52 extern int con_set_font(char * fontmap);
53 extern int con_get_font(char * fontmap);
54
55
56
57
58
59 #define GPFIRST 0x3b4
60 #define GPLAST 0x3df
61 #define GPNUM (GPLAST - GPFIRST + 1)
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78 static void
79 kd_nosound(unsigned long ignored)
80 {
81
82 outb(inb_p(0x61)&0xFC, 0x61);
83 return;
84 }
85
86 void
87 kd_mksound(unsigned int count, unsigned int ticks)
88 {
89 static struct timer_list sound_timer = { NULL, 0, 0, kd_nosound };
90
91 cli();
92 del_timer(&sound_timer);
93 if (count) {
94
95 outb_p(inb_p(0x61)|3, 0x61);
96
97 outb_p(0xB6, 0x43);
98
99 outb_p(count & 0xff, 0x42);
100 outb((count >> 8) & 0xff, 0x42);
101
102 if (ticks) {
103 sound_timer.expires = ticks;
104 add_timer(&sound_timer);
105 }
106 } else
107 kd_nosound(0);
108 sti();
109 return;
110 }
111
112
113
114
115
116 int vt_ioctl(struct tty_struct *tty, struct file * file,
117 unsigned int cmd, unsigned long arg)
118 {
119 int console, i;
120 unsigned char ucval;
121 struct kbd_struct * kbd;
122
123 console = tty->line - 1;
124
125 if (console < 0 || console >= NR_CONSOLES)
126 return -EINVAL;
127
128 kbd = kbd_table + console;
129 switch (cmd) {
130 case KIOCSOUND:
131 kd_mksound((unsigned int)arg, 0);
132 return 0;
133
134 case KDMKTONE:
135 {
136 unsigned int ticks = HZ * ((arg >> 16) & 0xffff) / 1000;
137
138
139
140
141
142 kd_mksound(arg & 0xffff, ticks);
143 if (ticks == 0)
144 kd_nosound(0);
145 return 0;
146 }
147
148 case KDGKBTYPE:
149
150
151
152 i = verify_area(VERIFY_WRITE, (void *) arg, sizeof(unsigned char));
153 if (!i)
154 put_fs_byte(KB_101, (char *) arg);
155 return i;
156
157 case KDADDIO:
158 case KDDELIO:
159
160
161
162
163 if (arg < GPFIRST || arg > GPLAST)
164 return -EINVAL;
165 return sys_ioperm(arg, 1, (cmd == KDADDIO)) ? -ENXIO : 0;
166
167 case KDENABIO:
168 case KDDISABIO:
169 return sys_ioperm(GPFIRST, GPNUM,
170 (cmd == KDENABIO)) ? -ENXIO : 0;
171
172 case KDSETMODE:
173
174
175
176
177
178 switch (arg) {
179 case KD_GRAPHICS:
180 break;
181 case KD_TEXT0:
182 case KD_TEXT1:
183 arg = KD_TEXT;
184 case KD_TEXT:
185 break;
186 default:
187 return -EINVAL;
188 }
189 if (vt_cons[console].vc_mode == (unsigned char) arg)
190 return 0;
191 vt_cons[console].vc_mode = (unsigned char) arg;
192 if (console != fg_console)
193 return 0;
194
195
196
197 if (arg == KD_TEXT)
198 unblank_screen();
199 else {
200 timer_active &= ~(1<<BLANK_TIMER);
201 blank_screen();
202 }
203 return 0;
204
205 case KDGETMODE:
206 i = verify_area(VERIFY_WRITE, (void *) arg, sizeof(unsigned long));
207 if (!i)
208 put_fs_long(vt_cons[console].vc_mode, (unsigned long *) arg);
209 return i;
210
211 case KDMAPDISP:
212 case KDUNMAPDISP:
213
214
215
216
217 return -EINVAL;
218
219 case KDSKBMODE:
220 switch(arg) {
221 case K_RAW:
222 set_vc_kbd_mode(kbd, VC_RAW);
223 clr_vc_kbd_mode(kbd, VC_MEDIUMRAW);
224 break;
225 case K_MEDIUMRAW:
226 clr_vc_kbd_mode(kbd, VC_RAW);
227 set_vc_kbd_mode(kbd, VC_MEDIUMRAW);
228 break;
229 case K_XLATE:
230 clr_vc_kbd_mode(kbd, VC_RAW);
231 clr_vc_kbd_mode(kbd, VC_MEDIUMRAW);
232 compute_shiftstate();
233 break;
234 default:
235 return -EINVAL;
236 }
237 flush_input(tty);
238 return 0;
239
240 case KDGKBMODE:
241 i = verify_area(VERIFY_WRITE, (void *) arg, sizeof(unsigned long));
242 if (!i) {
243 ucval = (vc_kbd_mode(kbd, VC_RAW) ? K_RAW :
244 vc_kbd_mode(kbd, VC_MEDIUMRAW) ? K_MEDIUMRAW :
245 K_XLATE);
246 put_fs_long(ucval, (unsigned long *) arg);
247 }
248 return i;
249
250
251
252 case KDSKBMETA:
253 switch(arg) {
254 case K_METABIT:
255 clr_vc_kbd_mode(kbd, VC_META);
256 break;
257 case K_ESCPREFIX:
258 set_vc_kbd_mode(kbd, VC_META);
259 break;
260 default:
261 return -EINVAL;
262 }
263 return 0;
264
265 case KDGKBMETA:
266 i = verify_area(VERIFY_WRITE, (void *) arg, sizeof(unsigned long));
267 if (!i) {
268 ucval = (vc_kbd_mode(kbd, VC_META) ? K_ESCPREFIX :
269 K_METABIT);
270 put_fs_long(ucval, (unsigned long *) arg);
271 }
272 return i;
273
274 case KDGKBENT:
275 {
276 struct kbentry * const a = (struct kbentry *)arg;
277 u_char s;
278
279 i = verify_area(VERIFY_WRITE, (void *)a, sizeof(struct kbentry));
280 if (i)
281 return i;
282 if ((i = get_fs_byte((char *) &a->kb_index)) >= NR_KEYS)
283 return -EINVAL;
284 if ((s = get_fs_byte((char *) &a->kb_table)) >= NR_KEYMAPS)
285 return -EINVAL;
286 put_fs_word(key_map[s][i], (short *) &a->kb_value);
287 return 0;
288 }
289
290 case KDSKBENT:
291 {
292 const struct kbentry * a = (struct kbentry *)arg;
293 u_char s;
294 u_short v;
295
296 i = verify_area(VERIFY_READ, (void *)a, sizeof(struct kbentry));
297 if (i)
298 return i;
299 if ((i = get_fs_byte((char *) &a->kb_index)) >= NR_KEYS)
300 return -EINVAL;
301 if ((s = get_fs_byte((char *) &a->kb_table)) >= NR_KEYMAPS)
302 return -EINVAL;
303 if (KTYP(v = get_fs_word(&a->kb_value)) >= NR_TYPES)
304 return -EINVAL;
305 if (KVAL(v) > max_vals[KTYP(v)])
306 return -EINVAL;
307 key_map[s][i] = v;
308 return 0;
309 }
310
311 case KDGKBSENT:
312 {
313 struct kbsentry *a = (struct kbsentry *)arg;
314 char *p;
315 u_char *q;
316
317 i = verify_area(VERIFY_WRITE, (void *)a, sizeof(struct kbsentry));
318 if (i)
319 return i;
320 if ((i = get_fs_byte(&a->kb_func)) >= NR_FUNC || i < 0)
321 return -EINVAL;
322 q = a->kb_string;
323 p = func_table[i];
324 if(!p) {
325
326 printk("KDGKBSENT error: func_table[%d] is nil.\n",
327 i);
328 return -EINVAL;
329 }
330 for ( ; *p; p++)
331 put_fs_byte(*p, q++);
332 put_fs_byte(0, q);
333 return 0;
334 }
335
336 case KDSKBSENT:
337 {
338 struct kbsentry * const a = (struct kbsentry *)arg;
339 int delta;
340 char *first_free;
341 int k;
342 u_char *p;
343 char *q;
344
345 i = verify_area(VERIFY_READ, (void *)a, sizeof(struct kbsentry));
346 if (i)
347 return i;
348 if ((i = get_fs_byte(&a->kb_func)) >= NR_FUNC)
349 return -EINVAL;
350 q = func_table[i];
351 if (!q) {
352
353 printk("KDSKBSENT error: func_table[%d] is nil.\n",
354 i);
355 return -EINVAL;
356 }
357 delta = -strlen(q);
358 for (p = a->kb_string; get_fs_byte(p); p++)
359 delta++;
360 first_free = func_table[NR_FUNC - 1] +
361 strlen(func_table[NR_FUNC - 1]) + 1;
362 if (
363 delta > 0 &&
364 first_free + delta > func_buf + FUNC_BUFSIZE
365 )
366 return -EINVAL;
367 if (i < NR_FUNC - 1) {
368 memmove(
369 func_table[i + 1] + delta,
370 func_table[i + 1],
371 first_free - func_table[i + 1]);
372 for (k = i + 1; k < NR_FUNC; k++)
373 if (func_table[k])
374 func_table[k] += delta;
375 }
376 for (p = a->kb_string, q = func_table[i]; ; p++, q++)
377 if (!(*q = get_fs_byte(p)))
378 break;
379 return 0;
380 }
381
382 case KDGKBDIACR:
383 {
384 struct kbdiacrs *a = (struct kbdiacrs *)arg;
385
386 i = verify_area(VERIFY_WRITE, (void *) a, sizeof(struct kbdiacrs));
387 if (i)
388 return i;
389 put_fs_long(accent_table_size, &a->kb_cnt);
390 memcpy_tofs(a->kbdiacr, accent_table,
391 accent_table_size*sizeof(struct kbdiacr));
392 return 0;
393 }
394
395 case KDSKBDIACR:
396 {
397 struct kbdiacrs *a = (struct kbdiacrs *)arg;
398 unsigned int ct;
399
400 i = verify_area(VERIFY_READ, (void *) a, sizeof(struct kbdiacrs));
401 if (i)
402 return i;
403 ct = get_fs_long(&a->kb_cnt);
404 if (ct >= MAX_DIACR)
405 return -EINVAL;
406 accent_table_size = ct;
407 memcpy_fromfs(accent_table, a->kbdiacr, ct*sizeof(struct kbdiacr));
408 return 0;
409 }
410
411 case KDGETLED:
412 i = verify_area(VERIFY_WRITE, (void *) arg, sizeof(unsigned char));
413 if (i)
414 return i;
415 put_fs_byte(kbd->ledstate, (char *) arg);
416 return 0;
417
418 case KDSETLED:
419 if (arg & ~7)
420 return -EINVAL;
421 kbd->ledstate = arg;
422 set_leds();
423 return 0;
424
425 case VT_SETMODE:
426 {
427 struct vt_mode *vtmode = (struct vt_mode *)arg;
428 char mode;
429
430 i = verify_area(VERIFY_WRITE, (void *)vtmode, sizeof(struct vt_mode));
431 if (i)
432 return i;
433 mode = get_fs_byte(&vtmode->mode);
434 if (mode != VT_AUTO && mode != VT_PROCESS)
435 return -EINVAL;
436 vt_cons[console].vt_mode.mode = mode;
437 vt_cons[console].vt_mode.waitv = get_fs_byte(&vtmode->waitv);
438 vt_cons[console].vt_mode.relsig = get_fs_word(&vtmode->relsig);
439 vt_cons[console].vt_mode.acqsig = get_fs_word(&vtmode->acqsig);
440
441 vt_cons[console].vt_mode.frsig = 0;
442 vt_cons[console].vt_pid = current->pid;
443 vt_cons[console].vt_newvt = 0;
444 return 0;
445 }
446
447 case VT_GETMODE:
448 {
449 struct vt_mode *vtmode = (struct vt_mode *)arg;
450
451 i = verify_area(VERIFY_WRITE, (void *)arg, sizeof(struct vt_mode));
452 if (i)
453 return i;
454 put_fs_byte(vt_cons[console].vt_mode.mode, &vtmode->mode);
455 put_fs_byte(vt_cons[console].vt_mode.waitv, &vtmode->waitv);
456 put_fs_word(vt_cons[console].vt_mode.relsig, &vtmode->relsig);
457 put_fs_word(vt_cons[console].vt_mode.acqsig, &vtmode->acqsig);
458 put_fs_word(vt_cons[console].vt_mode.frsig, &vtmode->frsig);
459 return 0;
460 }
461
462
463
464
465
466 case VT_GETSTATE:
467 {
468 struct vt_stat *vtstat = (struct vt_stat *)arg;
469 unsigned short state, mask;
470
471 i = verify_area(VERIFY_WRITE,(void *)vtstat, sizeof(struct vt_stat));
472 if (i)
473 return i;
474 put_fs_word(fg_console + 1, &vtstat->v_active);
475 state = 1;
476 for (i = 1, mask = 2; i <= NR_CONSOLES; ++i, mask <<= 1)
477 if (tty_table[i] && tty_table[i]->count > 0)
478 state |= mask;
479 put_fs_word(state, &vtstat->v_state);
480 return 0;
481 }
482
483
484
485
486 case VT_OPENQRY:
487 i = verify_area(VERIFY_WRITE, (void *) arg, sizeof(long));
488 if (i)
489 return i;
490 for (i = 1; i <= NR_CONSOLES; ++i)
491 if (!tty_table[i] || tty_table[i]->count == 0)
492 break;
493 put_fs_long(i <= NR_CONSOLES ? i : -1, (unsigned long *)arg);
494 return 0;
495
496
497
498
499
500
501 case VT_ACTIVATE:
502 if (arg == 0 || arg > NR_CONSOLES)
503 return -ENXIO;
504 change_console(arg - 1);
505 return 0;
506
507
508
509
510 case VT_WAITACTIVE:
511 if (arg == 0 || arg > NR_CONSOLES)
512 return -ENXIO;
513 while (fg_console != arg - 1)
514 {
515 if (vt_waitactive() < 0)
516 return -EINTR;
517 }
518 return 0;
519
520
521
522
523
524
525
526
527
528
529
530 case VT_RELDISP:
531 if (vt_cons[console].vt_mode.mode != VT_PROCESS)
532 return -EINVAL;
533
534
535
536
537 if (vt_cons[console].vt_newvt >= 0)
538 {
539 if (arg == 0)
540
541
542
543
544 vt_cons[console].vt_newvt = -1;
545
546 else
547 {
548
549
550
551
552 int newvt = vt_cons[console].vt_newvt;
553 vt_cons[console].vt_newvt = -1;
554 complete_change_console(newvt);
555 }
556 }
557
558
559
560
561 else
562 {
563
564
565
566 if (arg != VT_ACKACQ)
567 return -EINVAL;
568 }
569
570 return 0;
571
572 case PIO_FONT:
573 return con_set_font((char *)arg);
574
575
576 case GIO_FONT:
577 return con_get_font((char *)arg);
578
579
580 case PIO_SCRNMAP:
581 return con_set_trans((char *)arg);
582
583
584 case GIO_SCRNMAP:
585 return con_get_trans((char *)arg);
586
587
588 default:
589 return -EINVAL;
590 }
591 }