--- Gnu-Mach/i386/i386at/kd_event.c 2020/09/02 04:36:58 1.1.1.1 +++ Gnu-Mach/i386/i386at/kd_event.c 2020/09/02 04:49:20 1.1.1.5 @@ -1,25 +1,25 @@ -/* +/* * Mach Operating System * Copyright (c) 1991,1990,1989 Carnegie Mellon University * All Rights Reserved. - * + * * Permission to use, copy, modify and distribute this software and its * documentation is hereby granted, provided that both the copyright * notice and this permission notice appear in all copies of the * software, derivative works or modified versions, and any portions * thereof, and that both notices appear in supporting documentation. - * + * * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. - * + * * Carnegie Mellon requests users of this software to return to - * + * * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU * School of Computer Science * Carnegie Mellon University * Pittsburgh PA 15213-3890 - * + * * any improvements or extensions that they make and grant Carnegie Mellon * the rights to redistribute these changes. */ @@ -56,23 +56,19 @@ WITH THE USE OR PERFORMANCE OF THIS SOFT #include #include -#ifdef MACH_KERNEL -#include +#include +#include + +#include +#include #include -#else MACH_KERNEL -#include -#include -#include -#include -#include -#include -#include -#include -#endif MACH_KERNEL #include +#include #include #include +#include "kd_event.h" + /* * Code for /dev/kbd. The interrupt processing is done in kd.c, * which calls into this module to enqueue scancode events when @@ -85,24 +81,7 @@ WITH THE USE OR PERFORMANCE OF THIS SOFT */ kd_event_queue kbd_queue; /* queue of keyboard events */ -#ifdef MACH_KERNEL queue_head_t kbd_read_queue = { &kbd_read_queue, &kbd_read_queue }; -#else MACH_KERNEL -struct proc *kbd_sel = 0; /* selecting process, if any */ -short kbdpgrp = 0; /* process group leader when dev is open */ - -int kbdflag = 0; -#define KBD_COLL 1 /* select collision */ -#define KBD_ASYNC 2 /* user wants asynch notification */ -#define KBD_NBIO 4 /* user wants non-blocking I/O */ -#endif MACH_KERNEL - - -void kbd_enqueue(); -#ifdef MACH_KERNEL -io_return_t X_kdb_enter_init(); -io_return_t X_kdb_exit_init(); -#endif MACH_KERNEL static boolean_t initialized = FALSE; @@ -111,10 +90,11 @@ static boolean_t initialized = FALSE; * kbdinit - set up event queue. */ -kbdinit() +void +kbdinit(void) { spl_t s = SPLKD(); - + if (!initialized) { kdq_reset(&kbd_queue); initialized = TRUE; @@ -129,20 +109,17 @@ kbdinit() */ /*ARGSUSED*/ -kbdopen(dev, flags) +int +kbdopen(dev, flags, ior) dev_t dev; int flags; + io_req_t ior; { + spl_t o_pri = spltty(); + kdinit(); + splx(o_pri); kbdinit(); -#ifdef MACH_KERNEL -#else MACH_KERNEL - if (flags & FWRITE) - return(ENODEV); - - if (kbdpgrp == 0) - kbdpgrp = u.u_procp->p_pgrp; -#endif MACH_KERNEL return(0); } @@ -153,159 +130,84 @@ kbdopen(dev, flags) */ /*ARGSUSED*/ -kbdclose(dev, flags) - dev_t dev; - int flags; +void +kbdclose( + dev_t dev, + int flags) { spl_t s = SPLKD(); kb_mode = KB_ASCII; -#ifdef MACH_KERNEL -#else MACH_KERNEL - kbdpgrp = 0; - kbdflag = 0; - kbd_sel = 0; -#endif MACH_KERNEL kdq_reset(&kbd_queue); splx(s); } -#ifdef MACH_KERNEL -io_return_t kbdgetstat(dev, flavor, data, count) - dev_t dev; - int flavor; - int * data; /* pointer to OUT array */ - unsigned int *count; /* OUT */ +io_return_t kbdgetstat( + dev_t dev, + int flavor, + int * data, /* pointer to OUT array */ + unsigned int *count) /* OUT */ { - io_return_t result; - switch (flavor) { case KDGKBDTYPE: *data = KB_VANILLAKB; *count = 1; break; + case DEV_GET_SIZE: + data[DEV_GET_SIZE_DEVICE_SIZE] = 0; + data[DEV_GET_SIZE_RECORD_SIZE] = sizeof(kd_event); + *count = DEV_GET_SIZE_COUNT; + break; default: return (D_INVALID_OPERATION); } return (D_SUCCESS); } -io_return_t kbdsetstat(dev, flavor, data, count) - dev_t dev; - int flavor; - int * data; - unsigned int count; +io_return_t kbdsetstat( + dev_t dev, + int flavor, + int * data, + unsigned int count) { - io_return_t result; - switch (flavor) { case KDSKBDMODE: kb_mode = *data; /* XXX - what to do about unread events? */ /* XXX - should check that 'data' contains an OK valud */ break; + case KDSETLEDS: + if (count != 1) + return (D_INVALID_OPERATION); + kd_setleds1 (*data); + break; case K_X_KDB_ENTER: - return X_kdb_enter_init(data, count); + return X_kdb_enter_init((unsigned int *)data, count); case K_X_KDB_EXIT: - return X_kdb_exit_init(data, count); + return X_kdb_exit_init((unsigned int *)data, count); default: return (D_INVALID_OPERATION); } return (D_SUCCESS); } -#else MACH_KERNEL -/* - * kbdioctl - handling for asynch & non-blocking I/O. - */ - -/*ARGSUSED*/ -kbdioctl(dev, cmd, data, flag) - dev_t dev; - int cmd; - caddr_t data; - int flag; -{ - spl_t s = SPLKD(); - int err = 0; - - switch (cmd) { - case KDSKBDMODE: - kb_mode = *(int *)data; - /* XXX - what to do about unread events? */ - /* XXX - should check that "data" contains an OK value */ - break; - case KDGKBDTYPE: - *(int *)data = KB_VANILLAKB; - break; - case K_X_KDB_ENTER: - X_kdb_enter_init((struct X_kdb *) data); - break; - case K_X_KDB_EXIT: - X_kdb_exit_init( (struct X_kdb *) data); - break; - case FIONBIO: - if (*(int *)data) - kbdflag |= KBD_NBIO; - else - kbdflag &= ~KBD_NBIO; - break; - case FIOASYNC: - if (*(int *)data) - kbdflag |= KBD_ASYNC; - else - kbdflag &= ~KBD_ASYNC; - break; - default: - err = ENOTTY; - break; - } - - splx(s); - return(err); -} - - -/* - * kbdselect - */ - -/*ARGSUSED*/ -kbdselect(dev, rw) -{ - spl_t s = SPLKD(); - - if (!kdq_empty(&kbd_queue)) { - splx(s); - return(1); - } - - if (kbd_sel) - kbdflag |= KBD_COLL; - else - kbd_sel = (struct proc *)current_thread(); - /* eeeyuck */ - - splx(s); - return(0); -} -#endif MACH_KERNEL /* * kbdread - dequeue and return any queued events. */ - -#ifdef MACH_KERNEL -boolean_t kbd_read_done(); /* forward */ - -kbdread(dev, ior) - dev_t dev; - register io_req_t ior; -{ - register int err, count; - register spl_t s; +int +kbdread( + dev_t dev, + io_req_t ior) +{ + int err, count; + spl_t s; + + /* Check if IO_COUNT is a multiple of the record size. */ + if (ior->io_count % sizeof(kd_event) != 0) + return D_INVALID_SIZE; err = device_read_alloc(ior, (vm_size_t)ior->io_count); if (err != KERN_SUCCESS) @@ -324,7 +226,7 @@ kbdread(dev, ior) } count = 0; while (!kdq_empty(&kbd_queue) && count < ior->io_count) { - register kd_event *ev; + kd_event *ev; ev = kdq_get(&kbd_queue); *(kd_event *)(&ior->io_data[count]) = *ev; @@ -335,11 +237,10 @@ kbdread(dev, ior) return (D_SUCCESS); } -boolean_t kbd_read_done(ior) - register io_req_t ior; +boolean_t kbd_read_done(io_req_t ior) { - register int count; - register spl_t s; + int count; + spl_t s; s = SPLKD(); if (kdq_empty(&kbd_queue)) { @@ -351,7 +252,7 @@ boolean_t kbd_read_done(ior) count = 0; while (!kdq_empty(&kbd_queue) && count < ior->io_count) { - register kd_event *ev; + kd_event *ev; ev = kdq_get(&kbd_queue); *(kd_event *)(&ior->io_data[count]) = *ev; @@ -365,44 +266,6 @@ boolean_t kbd_read_done(ior) return (TRUE); } -#else MACH_KERNEL -/*ARGSUSED*/ -kbdread(dev, uio) - dev_t dev; - struct uio *uio; -{ - int s = SPLKD(); - int err = 0; - kd_event *ev; - int i; - char *cp; - - if (kdq_empty(&kbd_queue)) - if (kbdflag & KBD_NBIO) { - err = EWOULDBLOCK; - goto done; - } else - while (kdq_empty(&kbd_queue)) { - splx(s); - sleep((caddr_t)&kbd_queue, TTIPRI); - s = SPLKD(); - } - - while (!kdq_empty(&kbd_queue) && uio->uio_resid >= sizeof(kd_event)) { - ev = kdq_get(&kbd_queue); - for (cp = (char *)ev, i = 0; i < sizeof(kd_event); - ++i, ++cp) { - err = ureadc(*cp, uio); - if (err) - goto done; - } - } - -done: - splx(s); - return(err); -} -#endif MACH_KERNEL /* @@ -410,8 +273,7 @@ done: */ void -kd_enqsc(sc) - Scancode sc; +kd_enqsc(Scancode sc) { kd_event ev; @@ -428,39 +290,28 @@ kd_enqsc(sc) */ void -kbd_enqueue(ev) - kd_event *ev; +kbd_enqueue(kd_event *ev) { if (kdq_full(&kbd_queue)) - printf("kbd: queue full\n"); + printf_once("kbd: queue full\n"); else kdq_put(&kbd_queue, ev); -#ifdef MACH_KERNEL { - register io_req_t ior; + io_req_t ior; while ((ior = (io_req_t)dequeue_head(&kbd_read_queue)) != 0) iodone(ior); } -#else MACH_KERNEL - if (kbd_sel) { - selwakeup(kbd_sel, kbdflag & KBD_COLL); - kbd_sel = 0; - kbdflag &= ~KBD_COLL; - } - if (kbdflag & KBD_ASYNC) - gsignal(kbdpgrp, SIGIO); - wakeup((caddr_t)&kbd_queue); -#endif MACH_KERNEL } u_int X_kdb_enter_str[512], X_kdb_exit_str[512]; int X_kdb_enter_len = 0, X_kdb_exit_len = 0; +void kdb_in_out(p) -u_int *p; +const u_int *p; { -register int t = p[0]; + int t = p[0]; switch (t & K_X_TYPE) { case K_X_IN|K_X_BYTE: @@ -489,9 +340,10 @@ register int t = p[0]; } } -X_kdb_enter() +void +X_kdb_enter(void) { -register u_int *u_ip, *endp; + u_int *u_ip, *endp; for (u_ip = X_kdb_enter_str, endp = &X_kdb_enter_str[X_kdb_enter_len]; u_ip < endp; @@ -499,9 +351,10 @@ register u_int *u_ip, *endp; kdb_in_out(u_ip); } -X_kdb_exit() +void +X_kdb_exit(void) { -register u_int *u_ip, *endp; + u_int *u_ip, *endp; for (u_ip = X_kdb_exit_str, endp = &X_kdb_exit_str[X_kdb_exit_len]; u_ip < endp; @@ -509,52 +362,28 @@ register u_int *u_ip, *endp; kdb_in_out(u_ip); } -#ifdef MACH_KERNEL io_return_t -X_kdb_enter_init(data, count) - u_int *data; - u_int count; +X_kdb_enter_init( + u_int *data, + u_int count) { if (count * sizeof X_kdb_enter_str[0] > sizeof X_kdb_enter_str) return D_INVALID_OPERATION; - bcopy(data, X_kdb_enter_str, count * sizeof X_kdb_enter_str[0]); + memcpy(X_kdb_enter_str, data, count * sizeof X_kdb_enter_str[0]); X_kdb_enter_len = count; return D_SUCCESS; } io_return_t -X_kdb_exit_init(data, count) - u_int *data; - u_int count; +X_kdb_exit_init( + u_int *data, + u_int count) { if (count * sizeof X_kdb_exit_str[0] > sizeof X_kdb_exit_str) return D_INVALID_OPERATION; - bcopy(data, X_kdb_exit_str, count * sizeof X_kdb_exit_str[0]); + memcpy(X_kdb_exit_str, data, count * sizeof X_kdb_exit_str[0]); X_kdb_exit_len = count; return D_SUCCESS; } -#else MACH_KERNEL -X_kdb_enter_init(kp) -struct X_kdb *kp; -{ - if (kp->size > sizeof X_kdb_enter_str) - u.u_error = ENOENT; - else if(copyin(kp->ptr, X_kdb_enter_str, kp->size) == EFAULT) - u.u_error = EFAULT; - - X_kdb_enter_len = kp->size>>2; -} - -X_kdb_exit_init(kp) -struct X_kdb *kp; -{ - if (kp->size > sizeof X_kdb_exit_str) - u.u_error = ENOENT; - else if(copyin(kp->ptr, X_kdb_exit_str, kp->size) == EFAULT) - u.u_error = EFAULT; - - X_kdb_exit_len = kp->size>>2; -} -#endif MACH_KERNEL