Initial commit: Schunix as it stands before the SchOS rename
An x86-64 operating system built from xv6, now largely rewritten: SMP, a copy-on-write root filesystem (SchFS), PCI/USB/virtio drivers, a TTF rasteriser, and a Linux-numbered syscall ABI. No history before this point -- the tree was never under version control. This commit exists so the rename that follows has something to undo to.
This commit is contained in:
Nexoniarz
commit
d0f7acf9eb
275 changed files with 51417 additions and 0 deletions
394
kernel/dev/input.c
Normal file
394
kernel/dev/input.c
Normal file
|
|
@ -0,0 +1,394 @@
|
|||
// Raw input event devices -- /dev/input/event0 and /dev/input/event1.
|
||||
//
|
||||
// Everything that produces input feeds this: the PS/2 keyboard and mouse, and
|
||||
// the USB HID driver. The console keeps its own path and is unaffected; these
|
||||
// nodes are a *second* consumer of the same interrupts, so a program can read
|
||||
// keys while the shell still gets characters.
|
||||
//
|
||||
// Two devices rather than one because they are two devices. A compositor
|
||||
// grabs the pointer and leaves the keyboard alone, or the other way round, and
|
||||
// merging them into a single stream makes that impossible to express.
|
||||
|
||||
#include "types.h"
|
||||
#include "defs.h"
|
||||
#include "param.h"
|
||||
#include "mmu.h"
|
||||
#include "proc.h"
|
||||
#include "spinlock.h"
|
||||
#include "sleeplock.h"
|
||||
#include "fs.h"
|
||||
#include "file.h"
|
||||
#include "input.h"
|
||||
#include "errno.h"
|
||||
|
||||
#define NEVENT 256 // per device; ~10 seconds of frantic typing
|
||||
|
||||
struct input_dev {
|
||||
struct spinlock lock;
|
||||
struct input_event ev[NEVENT];
|
||||
uint r, w; // free-running; the difference is the count
|
||||
|
||||
// Exclusive grab (EVIOCGRAB). While set, keys still arrive here but stop
|
||||
// being handed to the console's line discipline.
|
||||
//
|
||||
// Without this a full-screen program does not really own the keyboard: it
|
||||
// reads /dev/input/event0 *and* the shell behind it reads the same keystrokes
|
||||
// off the tty. The observed failure was a full-screen program quietly typing
|
||||
// its entire session into the shell underneath, so the first Enter after
|
||||
// exiting ran whatever had accumulated. The grab is also exactly what a
|
||||
// compositor needs, which is why it lives here rather than in any one client.
|
||||
int grabbed;
|
||||
|
||||
// How many descriptors are open on this device.
|
||||
//
|
||||
// Events are only queued while this is non-zero, and the backlog is dropped
|
||||
// on the first open. Both halves matter: without them the ring is a log of
|
||||
// every key pressed since boot, and the next program to open the device is
|
||||
// handed the lot as though the user had just typed it.
|
||||
int opens;
|
||||
};
|
||||
|
||||
static struct input_dev idev[NINPUTDEV];
|
||||
static int input_up;
|
||||
|
||||
extern uint ticks;
|
||||
|
||||
void
|
||||
inputinit(void)
|
||||
{
|
||||
int i;
|
||||
|
||||
for(i = 0; i < NINPUTDEV; i++)
|
||||
initlock(&idev[i].lock, "input");
|
||||
|
||||
// Producers run from interrupt handlers and can fire before this point in
|
||||
// boot. Until the locks exist, an event has nowhere safe to go.
|
||||
__sync_synchronize();
|
||||
input_up = 1;
|
||||
}
|
||||
|
||||
// Append one event. Called from interrupt context, so it never sleeps and
|
||||
// never blocks on a full ring.
|
||||
void
|
||||
input_report(int dev, int type, int code, int value)
|
||||
{
|
||||
struct input_dev *d;
|
||||
struct input_event *e;
|
||||
|
||||
if(!input_up || dev < 0 || dev >= NINPUTDEV)
|
||||
return;
|
||||
d = &idev[dev];
|
||||
|
||||
// Nobody is listening, so there is nowhere for this to go. Linux does the
|
||||
// same: an evdev device with no clients does not accumulate.
|
||||
if(d->opens == 0)
|
||||
return;
|
||||
|
||||
acquire(&d->lock);
|
||||
|
||||
// A full ring drops the *oldest* event, not the newest. Dropping the newest
|
||||
// is the obvious choice and it is wrong: the event most likely to be lost is
|
||||
// then a key release, and a lost release leaves the key held down forever
|
||||
// as far as every reader is concerned. Losing the oldest costs history, not
|
||||
// state.
|
||||
if(d->w - d->r >= NEVENT)
|
||||
d->r++;
|
||||
|
||||
e = &d->ev[d->w % NEVENT];
|
||||
e->time.tv_sec = ticks / 100;
|
||||
e->time.tv_usec = (ticks % 100) * 10000;
|
||||
e->type = (uint16)type;
|
||||
e->code = (uint16)code;
|
||||
e->value = (int32)value;
|
||||
d->w++;
|
||||
|
||||
release(&d->lock);
|
||||
}
|
||||
|
||||
// End a report. A reader that acts on each event as it arrives will see a
|
||||
// diagonal mouse move as two separate moves; the SYN is how it knows the two
|
||||
// axes belong to the same physical motion.
|
||||
void
|
||||
input_sync(int dev)
|
||||
{
|
||||
if(!input_up || dev < 0 || dev >= NINPUTDEV)
|
||||
return;
|
||||
input_report(dev, EV_SYN, SYN_REPORT, 0);
|
||||
wakeup(&idev[dev]);
|
||||
}
|
||||
|
||||
int
|
||||
input_ready(int dev)
|
||||
{
|
||||
int n;
|
||||
|
||||
if(!input_up || dev < 0 || dev >= NINPUTDEV)
|
||||
return 0;
|
||||
acquire(&idev[dev].lock);
|
||||
n = idev[dev].w != idev[dev].r;
|
||||
release(&idev[dev].lock);
|
||||
return n;
|
||||
}
|
||||
|
||||
// A descriptor has been opened on this device.
|
||||
//
|
||||
// The backlog is discarded, which is the whole point. Events queued before a
|
||||
// program opened the device were meant for whoever had it *then* -- almost
|
||||
// always the shell, which already consumed them as a command line. Replaying
|
||||
// them into the new owner means a program is handed the keystrokes that
|
||||
// launched it, as input, the instant it starts. That was a real crash and not a
|
||||
// cosmetic one: the replayed characters were interpreted as commands, and one of
|
||||
// them asked for a mode the program had not initialised yet.
|
||||
//
|
||||
// Linux gets this for free by giving every open its own client queue. One
|
||||
// shared ring plus "start from now" is the same answer for a single reader,
|
||||
// which is the case that exists.
|
||||
void
|
||||
inputopen(struct inode *ip)
|
||||
{
|
||||
int dev = ip->minor;
|
||||
|
||||
if(dev < 0 || dev >= NINPUTDEV)
|
||||
return;
|
||||
acquire(&idev[dev].lock);
|
||||
idev[dev].opens++;
|
||||
idev[dev].r = idev[dev].w; // start from now, not from boot
|
||||
release(&idev[dev].lock);
|
||||
}
|
||||
|
||||
// The devsw ready hook: would a read block?
|
||||
int
|
||||
inputready(struct inode *ip)
|
||||
{
|
||||
return input_ready(ip->minor);
|
||||
}
|
||||
|
||||
// Is this device grabbed? Asked by the keyboard drivers before they hand a
|
||||
// character to the console.
|
||||
int
|
||||
input_is_grabbed(int dev)
|
||||
{
|
||||
if(!input_up || dev < 0 || dev >= NINPUTDEV)
|
||||
return 0;
|
||||
return idev[dev].grabbed;
|
||||
}
|
||||
|
||||
// EVIOCGRAB. Linux's semantics: one holder at a time, and it is not an error
|
||||
// to grab what you already hold.
|
||||
int
|
||||
input_grab(int dev, int on)
|
||||
{
|
||||
if(!input_up || dev < 0 || dev >= NINPUTDEV)
|
||||
return -ENODEV;
|
||||
on = on ? 1 : 0;
|
||||
if(idev[dev].grabbed != on){
|
||||
idev[dev].grabbed = on;
|
||||
// Said out loud. A grabbed keyboard is a console that has gone deaf on
|
||||
// purpose, and that is indistinguishable from one that has gone deaf by
|
||||
// accident unless the kernel says which it was.
|
||||
cprintf("input: event%d %s by pid %d\n", dev,
|
||||
on ? "grabbed" : "released", myproc() ? myproc()->pid : -1);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
// The last descriptor on this device is going away.
|
||||
//
|
||||
// Releasing the grab here is not tidiness, it is the difference between a
|
||||
// crashed game and a machine you have to reboot: a program that grabs the
|
||||
// keyboard and dies without ungrabbing would leave the console permanently
|
||||
// deaf. The close hook makes the release unconditional.
|
||||
void
|
||||
inputclose(struct inode *ip)
|
||||
{
|
||||
int dev = ip->minor;
|
||||
|
||||
if(dev < 0 || dev >= NINPUTDEV)
|
||||
return;
|
||||
if(idev[dev].opens > 0)
|
||||
idev[dev].opens--;
|
||||
if(idev[dev].grabbed){
|
||||
idev[dev].grabbed = 0;
|
||||
cprintf("input: event%d grab released\n", dev);
|
||||
}
|
||||
}
|
||||
|
||||
// ioctl on /dev/input/eventN. Only EVIOCGRAB so far; the EVIOCG* query
|
||||
// requests (name, id, capability bitmaps) can arrive when something needs
|
||||
// them.
|
||||
int
|
||||
input_ioctl(struct inode *ip, int request, addr_t arg)
|
||||
{
|
||||
int on;
|
||||
|
||||
if(request == EVIOCGRAB){
|
||||
// Linux passes the flag *by value* in the argument, not by pointer.
|
||||
on = (int)arg;
|
||||
return input_grab(ip->minor, on);
|
||||
}
|
||||
return -ENOTTY;
|
||||
}
|
||||
|
||||
// A read returns whole events only. Handing back a partial struct would
|
||||
// desynchronise the reader permanently -- every later event would be split
|
||||
// across two reads and reassembled wrong.
|
||||
int
|
||||
inputread(struct inode *ip, uint off, char *dst, int n)
|
||||
{
|
||||
struct input_dev *d;
|
||||
int got = 0;
|
||||
int dev = ip->minor;
|
||||
|
||||
if(dev < 0 || dev >= NINPUTDEV)
|
||||
return -ENODEV;
|
||||
if(n < (int)sizeof(struct input_event))
|
||||
return -EINVAL;
|
||||
d = &idev[dev];
|
||||
|
||||
acquire(&d->lock);
|
||||
while(d->r == d->w){
|
||||
if(myproc()->killed){
|
||||
release(&d->lock);
|
||||
return -EINTR;
|
||||
}
|
||||
sleep(d, &d->lock);
|
||||
}
|
||||
|
||||
while(d->r != d->w && got + (int)sizeof(struct input_event) <= n){
|
||||
memmove(dst + got, &d->ev[d->r % NEVENT], sizeof(struct input_event));
|
||||
d->r++;
|
||||
got += sizeof(struct input_event);
|
||||
}
|
||||
release(&d->lock);
|
||||
return got;
|
||||
}
|
||||
|
||||
// evdev accepts writes to set keyboard LEDs. There are no LEDs to set here,
|
||||
// and a program that writes one should not see an error for it.
|
||||
int
|
||||
inputwrite(struct inode *ip, uint off, char *src, int n)
|
||||
{
|
||||
return n;
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Producers
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
// AT scancode set 1, E0-prefixed. The unprefixed bytes need no table at all:
|
||||
// Linux's keycodes were numbered from this set and still match it below 0x54.
|
||||
// These are the ones that do not.
|
||||
static const struct { uint8 sc; uint8 key; } e0map[] = {
|
||||
{0x1C, 96}, // KP_ENTER
|
||||
{0x1D, KEY_RIGHTCTRL},
|
||||
{0x35, 98}, // KP_SLASH
|
||||
{0x38, KEY_RIGHTALT},
|
||||
{0x47, KEY_HOME},
|
||||
{0x48, KEY_UP},
|
||||
{0x49, KEY_PAGEUP},
|
||||
{0x4B, KEY_LEFT},
|
||||
{0x4D, KEY_RIGHT},
|
||||
{0x4F, KEY_END},
|
||||
{0x50, KEY_DOWN},
|
||||
{0x51, KEY_PAGEDOWN},
|
||||
{0x52, KEY_INSERT},
|
||||
{0x53, KEY_DELETE},
|
||||
{0x5B, KEY_LEFTMETA},
|
||||
{0x5C, KEY_RIGHTMETA},
|
||||
};
|
||||
|
||||
// One byte from the PS/2 port, before it has been turned into a character.
|
||||
void
|
||||
input_ps2_scancode(int raw, int e0)
|
||||
{
|
||||
int code = raw & 0x7F;
|
||||
int down = (raw & 0x80) ? 0 : 1;
|
||||
int key = 0;
|
||||
unsigned i;
|
||||
|
||||
if(e0){
|
||||
for(i = 0; i < sizeof(e0map)/sizeof(e0map[0]); i++)
|
||||
if(e0map[i].sc == code){
|
||||
key = e0map[i].key;
|
||||
break;
|
||||
}
|
||||
if(key == 0)
|
||||
return; // an E0 key nothing has a name for
|
||||
} else {
|
||||
if(code == 0 || code > 0x58)
|
||||
return;
|
||||
key = code;
|
||||
}
|
||||
|
||||
input_report(INPUT_KBD, EV_KEY, key, down);
|
||||
input_sync(INPUT_KBD);
|
||||
}
|
||||
|
||||
// USB HID usage -> Linux keycode. The mapping is not derivable: HID numbers
|
||||
// keys by position on a US layout starting at 'a', and the AT set numbers them
|
||||
// by the order IBM wired the matrix. The table is the same one Linux carries
|
||||
// for the same reason.
|
||||
static const uint8 hid_keycode[] = {
|
||||
0, 0, 0, 0, 30, 48, 46, 32, 18, 33, 34, 35, 23, 36, 37, 38,
|
||||
50, 49, 24, 25, 16, 19, 31, 20, 22, 47, 17, 45, 21, 44, 2, 3,
|
||||
4, 5, 6, 7, 8, 9, 10, 11, 28, 1, 14, 15, 57, 12, 13, 26,
|
||||
27, 43, 43, 39, 40, 41, 51, 52, 53, 58, 59, 60, 61, 62, 63, 64,
|
||||
65, 66, 67, 68, 87, 88, 99, 70,119,110,102,104,111,107,109,106,
|
||||
105,108,103, 69, 98, 55, 74, 78, 96, 79, 80, 81, 75, 76, 77, 71,
|
||||
72, 73, 82, 83, 86,127,116,117,
|
||||
};
|
||||
|
||||
// The eight modifier bits in a boot report, in bit order.
|
||||
static const uint8 hid_modkey[8] = {
|
||||
KEY_LEFTCTRL, KEY_LEFTSHIFT, KEY_LEFTALT, KEY_LEFTMETA,
|
||||
KEY_RIGHTCTRL, KEY_RIGHTSHIFT, KEY_RIGHTALT, KEY_RIGHTMETA,
|
||||
};
|
||||
|
||||
int
|
||||
input_hid_keycode(int usage)
|
||||
{
|
||||
if(usage >= 0xE0 && usage <= 0xE7)
|
||||
return hid_modkey[usage - 0xE0];
|
||||
if(usage < 0 || usage >= (int)sizeof(hid_keycode))
|
||||
return 0;
|
||||
return hid_keycode[usage];
|
||||
}
|
||||
|
||||
void
|
||||
input_key(int usage, int down)
|
||||
{
|
||||
int key = input_hid_keycode(usage);
|
||||
|
||||
if(key == 0)
|
||||
return;
|
||||
input_report(INPUT_KBD, EV_KEY, key, down);
|
||||
input_sync(INPUT_KBD);
|
||||
}
|
||||
|
||||
// One mouse report: relative motion plus the current button state. `buttons`
|
||||
// is a bitmask in the order both PS/2 and HID boot protocol use -- left,
|
||||
// right, middle -- which is why neither caller has to reorder it.
|
||||
void
|
||||
input_mouse(int dx, int dy, int buttons)
|
||||
{
|
||||
static int last;
|
||||
static const int btncode[3] = { BTN_LEFT, BTN_RIGHT, BTN_MIDDLE };
|
||||
int i;
|
||||
|
||||
if(dx)
|
||||
input_report(INPUT_MOUSE, EV_REL, REL_X, dx);
|
||||
if(dy)
|
||||
input_report(INPUT_MOUSE, EV_REL, REL_Y, dy);
|
||||
|
||||
// Only transitions. A button held down for a second is one press event, not
|
||||
// a hundred -- a reader that has to filter repeats itself cannot tell a held
|
||||
// button from a very fast double-click.
|
||||
for(i = 0; i < 3; i++){
|
||||
int now = (buttons >> i) & 1;
|
||||
if(now != ((last >> i) & 1))
|
||||
input_report(INPUT_MOUSE, EV_KEY, btncode[i], now);
|
||||
}
|
||||
last = buttons;
|
||||
|
||||
input_sync(INPUT_MOUSE);
|
||||
}
|
||||
Loading…
Reference in a new issue