andreacavalli/xserver-multidpi
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

remove undead files from master

Browse Source 
Remove dead files which worked their way back in when merging from master.
Ugh.
This commit is contained in:
Daniel Stone 2006-07-21 19:10:26 -04:00 committed by Daniel Stone
parent 7465010d59
commit 81913a1291
7 changed files with 0 additions and 3933 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

470
hw/xfree86/common/xf86Io.c
View File

@ -1,470 +0,0 @@
/*
* Copyright 1990,91 by Thomas Roell, Dinkelscherben, Germany.
*
* Permission to use, copy, modify, distribute, and sell this software and its
* documentation for any purpose is hereby granted without fee, provided that
* the above copyright notice appear in all copies and that both that
* copyright notice and this permission notice appear in supporting
* documentation, and that the name of Thomas Roell not be used in
* advertising or publicity pertaining to distribution of the software without
* specific, written prior permission. Thomas Roell makes no representations
* about the suitability of this software for any purpose. It is provided
* "as is" without express or implied warranty.
*
* THOMAS ROELL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
* EVENT SHALL THOMAS ROELL BE LIABLE FOR ANY SPECIAL, INDIRECT OR
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*
*/
/*
* Copyright (c) 1992-2003 by The XFree86 Project, Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*
* Except as contained in this notice, the name of the copyright holder(s)
* and author(s) shall not be used in advertising or otherwise to promote
* the sale, use or other dealings in this Software without prior written
* authorization from the copyright holder(s) and author(s).
*/
/* $XConsortium: xf86Io.c /main/27 1996/10/19 17:58:55 kaleb $ */
#define NEED_EVENTS
#ifdef HAVE_XORG_CONFIG_H
#include <xorg-config.h>
#endif
#include <X11/X.h>
#include <X11/Xproto.h>
#include "inputstr.h"
#include "scrnintstr.h"
#include "compiler.h"
#include "xf86.h"
#include "xf86Priv.h"
#define XF86_OS_PRIVS
#include "xf86_OSlib.h"
#include "mipointer.h"
#ifdef XINPUT
#include "xf86Xinput.h"
#include <X11/extensions/XIproto.h>
#include "exevents.h"
#endif
#ifdef XKB
#include <X11/extensions/XKB.h>
#include <X11/extensions/XKBstr.h>
#include <X11/extensions/XKBsrv.h>
#endif
unsigned int xf86InitialCaps = 0;
unsigned int xf86InitialNum = 0;
unsigned int xf86InitialScroll = 0;
#include "atKeynames.h"
/*
* xf86KbdBell --
* Ring the terminal/keyboard bell for an amount of time proportional to
* "loudness".
*/
void
xf86KbdBell(percent, pKeyboard, ctrl, unused)
int percent; /* Percentage of full volume */
DeviceIntPtr pKeyboard; /* Keyboard to ring */
pointer ctrl;
int unused;
{
xf86SoundKbdBell(percent, xf86Info.bell_pitch, xf86Info.bell_duration);
}
void
xf86UpdateKbdLeds()
{
int leds = 0;
if (xf86Info.capsLock) leds |= XLED1;
if (xf86Info.numLock) leds |= XLED2;
if (xf86Info.scrollLock || xf86Info.modeSwitchLock) leds |= XLED3;
if (xf86Info.composeLock) leds |= XLED4;
xf86Info.leds = (xf86Info.leds & xf86Info.xleds) | (leds & ~xf86Info.xleds);
xf86KbdLeds();
}
void
xf86KbdLeds ()
{
int leds, real_leds = 0;
#if defined (__sparc__) && defined(__linux__)
static int kbdSun = -1;
if (kbdSun == -1) {
if ((xf86Info.xkbmodel && !strcmp(xf86Info.xkbmodel, "sun")) ||
(xf86Info.xkbrules && !strcmp(xf86Info.xkbrules, "sun")))
kbdSun = 1;
else
kbdSun = 0;
}
if (kbdSun) {
if (xf86Info.leds & 0x08) real_leds |= XLED1;
if (xf86Info.leds & 0x04) real_leds |= XLED3;
if (xf86Info.leds & 0x02) real_leds |= XLED4;
if (xf86Info.leds & 0x01) real_leds |= XLED2;
leds = real_leds;
real_leds = 0;
} else {
leds = xf86Info.leds;
}
#else
leds = xf86Info.leds;
#endif /* defined (__sparc__) */
#ifdef LED_CAP
if (leds & XLED1) real_leds |= LED_CAP;
if (leds & XLED2) real_leds |= LED_NUM;
if (leds & XLED3) real_leds |= LED_SCR;
#ifdef LED_COMP
if (leds & XLED4) real_leds |= LED_COMP;
#else
if (leds & XLED4) real_leds |= LED_SCR;
#endif
#endif
#ifdef sun
/* Pass through any additional LEDs, such as Kana LED on Sun Japanese kbd */
real_leds |= (leds & 0xFFFFFFF0);
#endif
xf86SetKbdLeds(real_leds);
(void)leds;
}
/*
* xf86KbdCtrl --
* Alter some of the keyboard control parameters. All special protocol
* values are handled by dix (ProgChangeKeyboardControl)
*/
void
xf86KbdCtrl (pKeyboard, ctrl)
DevicePtr pKeyboard; /* Keyboard to alter */
KeybdCtrl *ctrl;
{
int leds;
xf86Info.bell_pitch = ctrl->bell_pitch;
xf86Info.bell_duration = ctrl->bell_duration;
xf86Info.autoRepeat = ctrl->autoRepeat;
xf86Info.composeLock = (ctrl->leds & XCOMP) ? TRUE : FALSE;
leds = (ctrl->leds & ~(XCAPS | XNUM | XSCR));
#ifdef XKB
if (noXkbExtension) {
#endif
xf86Info.leds = (leds & xf86Info.xleds)|(xf86Info.leds & ~xf86Info.xleds);
#ifdef XKB
} else {
xf86Info.leds = leds;
}
#endif
xf86KbdLeds();
}
/*
* xf86InitKBD --
* Reinitialize the keyboard. Only set Lockkeys according to ours leds.
* Depress all other keys.
*/
void
xf86InitKBD(init)
Bool init;
{
char leds = 0, rad;
unsigned int i;
xEvent kevent;
DeviceIntPtr pKeyboard = xf86Info.pKeyboard;
KeyClassRec *keyc = xf86Info.pKeyboard->key;
KeySym *map = keyc->curKeySyms.map;
kevent.u.keyButtonPointer.time = GetTimeInMillis();
kevent.u.keyButtonPointer.rootX = 0;
kevent.u.keyButtonPointer.rootY = 0;
/*
* Hmm... here is the biggest hack of every time !
* It may be possible that a switch-vt procedure has finished BEFORE
* you released all keys neccessary to do this. That peculiar behavior
* can fool the X-server pretty much, cause it assumes that some keys
* were not released. TWM may stuck alsmost completly....
* OK, what we are doing here is after returning from the vt-switch
* exeplicitely unrelease all keyboard keys before the input-devices
* are reenabled.
*/
for (i = keyc->curKeySyms.minKeyCode, map = keyc->curKeySyms.map;
i < keyc->curKeySyms.maxKeyCode;
i++, map += keyc->curKeySyms.mapWidth)
if (KeyPressed(i))
{
switch (*map) {
/* Don't release the lock keys */
case XK_Caps_Lock:
case XK_Shift_Lock:
case XK_Num_Lock:
case XK_Scroll_Lock:
case XK_Kana_Lock:
break;
default:
kevent.u.u.detail = i;
kevent.u.u.type = KeyRelease;
(* pKeyboard->public.processInputProc)(&kevent, pKeyboard, 1);
}
}
xf86Info.scanPrefix = 0;
if (init)
{
/*
* we must deal here with the fact, that on some cases the numlock or
* capslock key are enabled BEFORE the server is started up. So look
* here at the state on the according LEDS to determine whether a
* lock-key is already set.
*/
xf86Info.capsLock = FALSE;
xf86Info.numLock = FALSE;
xf86Info.scrollLock = FALSE;
xf86Info.modeSwitchLock = FALSE;
xf86Info.composeLock = FALSE;
#ifdef LED_CAP
#ifdef INHERIT_LOCK_STATE
leds = xf86Info.leds;
for (i = keyc->curKeySyms.minKeyCode, map = keyc->curKeySyms.map;
i < keyc->curKeySyms.maxKeyCode;
i++, map += keyc->curKeySyms.mapWidth)
switch(*map) {
case XK_Caps_Lock:
case XK_Shift_Lock:
if (leds & LED_CAP)
{
xf86InitialCaps = i;
xf86Info.capsLock = TRUE;
}
break;
case XK_Num_Lock:
if (leds & LED_NUM)
{
xf86InitialNum = i;
xf86Info.numLock = TRUE;
}
break;
case XK_Scroll_Lock:
case XK_Kana_Lock:
if (leds & LED_SCR)
{
xf86InitialScroll = i;
xf86Info.scrollLock = TRUE;
}
break;
}
#endif /* INHERIT_LOCK_STATE */
xf86SetKbdLeds(leds);
#endif /* LED_CAP */
(void)leds;
if (xf86Info.kbdDelay <= 375) rad = 0x00;
else if (xf86Info.kbdDelay <= 625) rad = 0x20;
else if (xf86Info.kbdDelay <= 875) rad = 0x40;
else rad = 0x60;
if (xf86Info.kbdRate <= 2) rad |= 0x1F;
else if (xf86Info.kbdRate >= 30) rad |= 0x00;
else rad |= ((58 / xf86Info.kbdRate) - 2);
xf86SetKbdRepeat(rad);
}
}
/*
* xf86KbdProc --
* Handle the initialization, etc. of a keyboard.
*/
int
xf86KbdProc (pKeyboard, what)
DeviceIntPtr pKeyboard; /* Keyboard to manipulate */
int what; /* What to do to it */
{
KeySymsRec keySyms;
CARD8 modMap[MAP_LENGTH];
int kbdFd;
switch (what) {
case DEVICE_INIT:
/*
* First open and find the current state of the keyboard.
*/
xf86KbdInit();
xf86KbdGetMapping(&keySyms, modMap);
#ifndef XKB
defaultKeyboardControl.leds = xf86GetKbdLeds();
#else
defaultKeyboardControl.leds = 0;
#endif
/*
* Perform final initialization of the system private keyboard
* structure and fill in various slots in the device record
* itself which couldn't be filled in before.
*/
pKeyboard->public.on = FALSE;
#ifdef XKB
if (noXkbExtension) {
#endif
InitKeyboardDeviceStruct((DevicePtr)xf86Info.pKeyboard,
&keySyms,
modMap,
xf86KbdBell,
(KbdCtrlProcPtr)xf86KbdCtrl);
#ifdef XKB
} else {
XkbComponentNamesRec names;
XkbDescPtr desc;
Bool foundTerminate = FALSE;
int keyc;
if (xf86Info.xkbkeymap) {
names.keymap = xf86Info.xkbkeymap;
names.keycodes = NULL;
names.types = NULL;
names.compat = NULL;
names.symbols = NULL;
names.geometry = NULL;
} else {
names.keymap = NULL;
names.keycodes = xf86Info.xkbkeycodes;
names.types = xf86Info.xkbtypes;
names.compat = xf86Info.xkbcompat;
names.symbols = xf86Info.xkbsymbols;
names.geometry = xf86Info.xkbgeometry;
}
if ((xf86Info.xkbkeymap || xf86Info.xkbcomponents_specified)
&& (xf86Info.xkbmodel == NULL || xf86Info.xkblayout == NULL)) {
xf86Info.xkbrules = NULL;
}
XkbSetRulesDflts(xf86Info.xkbrules, xf86Info.xkbmodel,
xf86Info.xkblayout, xf86Info.xkbvariant,
xf86Info.xkboptions);
XkbInitKeyboardDeviceStruct(pKeyboard,
&names,
&keySyms,
modMap,
xf86KbdBell,
(KbdCtrlProcPtr)xf86KbdCtrl);
/* Search keymap for Terminate action */
desc = pKeyboard->key->xkbInfo->desc;
for (keyc = desc->min_key_code; keyc <= desc->max_key_code; keyc++) {
int i;
for (i = 1; i <= XkbKeyNumActions(desc, keyc); i++) {
if (XkbKeyAction(desc, keyc, i)
&& XkbKeyAction(desc, keyc, i)->type == XkbSA_Terminate) {
foundTerminate = TRUE;
goto searchdone;
}
}
}
searchdone:
xf86Info.ActionKeyBindingsSet = foundTerminate;
if (!foundTerminate)
xf86Msg(X_INFO, "Server_Terminate keybinding not found\n");
}
#endif
xf86InitKBD(TRUE);
break;
case DEVICE_ON:
/*
* Set the keyboard into "direct" mode and turn on
* event translation.
*/
kbdFd = xf86KbdOn();
/*
* Discard any pending input after a VT switch to prevent the server
* passing on parts of the VT switch sequence.
*/
sleep(1);
#if defined(WSCONS_SUPPORT)
if (xf86Info.consType != WSCONS) {
#endif
if (kbdFd != -1) {
char buf[16];
read(kbdFd, buf, 16);
}
#if defined(WSCONS_SUPPORT)
}
#endif
#if !defined(__UNIXOS2__) /* Under EMX, keyboard cannot be select()'ed */
if (kbdFd != -1)
AddEnabledDevice(kbdFd);
#endif /* __UNIXOS2__ */
pKeyboard->public.on = TRUE;
xf86InitKBD(FALSE);
break;
case DEVICE_CLOSE:
case DEVICE_OFF:
/*
* Restore original keyboard directness and translation.
*/
kbdFd = xf86KbdOff();
if (kbdFd != -1)
RemoveEnabledDevice(kbdFd);
pKeyboard->public.on = FALSE;
break;
}
return (Success);
}

394
hw/xfree86/common/xf86Kbd.c
View File

@ -1,394 +0,0 @@
/*
* Copyright 1990,91 by Thomas Roell, Dinkelscherben, Germany.
*
* Permission to use, copy, modify, distribute, and sell this software and its
* documentation for any purpose is hereby granted without fee, provided that
* the above copyright notice appear in all copies and that both that
* copyright notice and this permission notice appear in supporting
* documentation, and that the name of Thomas Roell not be used in
* advertising or publicity pertaining to distribution of the software without
* specific, written prior permission. Thomas Roell makes no representations
* about the suitability of this software for any purpose. It is provided
* "as is" without express or implied warranty.
*
* THOMAS ROELL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
* EVENT SHALL THOMAS ROELL BE LIABLE FOR ANY SPECIAL, INDIRECT OR
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*
*/
/*
* Copyright (c) 1992-2003 by The XFree86 Project, Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*
* Except as contained in this notice, the name of the copyright holder(s)
* and author(s) shall not be used in advertising or otherwise to promote
* the sale, use or other dealings in this Software without prior written
* authorization from the copyright holder(s) and author(s).
*/
/* $XConsortium: xf86Kbd.c /main/10 1996/02/21 17:38:32 kaleb $ */
#ifdef HAVE_XORG_CONFIG_H
#include <xorg-config.h>
#endif
#ifdef __UNIXOS2__
#define I_NEED_OS2_H
#endif
#include <X11/X.h>
#include <X11/Xmd.h>
#include "input.h"
#include "scrnintstr.h"
#include "compiler.h"
#include "xf86.h"
#include "xf86Priv.h"
#include "xf86_OSlib.h"
#include "atKeynames.h"
#include "xf86Config.h"
#include "xf86Keymap.h"
#if defined(KDGKBTYPE) && \
!defined(Lynx) && \
!defined(__UNIXOS2__) && !defined(__mips__) && \
!defined(__arm32__) && !defined(__GNU__) && !defined(__QNX__)
#define HAS_GETKBTYPE
#endif
#if defined(GIO_KEYMAP) && \
!defined(Lynx) && \
!defined(__UNIXOS2__) && !defined(__mips__) && \
!defined(__arm32__) && !defined(__GNU__) && !defined(DGUX) && \
!defined(__QNX__)
#define HAS_GETKEYMAP
#define KD_GET_ENTRY(i,n) \
eascii_to_x[((keymap.key[i].spcl << (n+1)) & 0x100) + keymap.key[i].map[n]]
/*
* NOTE: Not all possible remappable symbols are remapped. There are two main
* reasons:
* a) The mapping between scancode and SYSV/386 - symboltable
* is inconsistent between different versions and has some
* BIG mistakes.
* b) In X-Windows there is a difference between numpad-keys
* and normal keys. SYSV/386 uses for both kinds of keys
* the same symbol.
*
* Thus only the alpha keypad and the function keys are translated.
* Also CapsLock, NumLock, ScrollLock, Shift, Control & Alt.
*/
static unsigned char remap[128] = {
0, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, /* 0x00 - 0x07 */
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, /* 0x08 - 0x0f */
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, /* 0x10 - 0x17 */
0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, /* 0x18 - 0x1f */
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, /* 0x20 - 0x27 */
0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, /* 0x28 - 0x2f */
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0, /* 0x30 - 0x37 */
0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, /* 0x38 - 0x3f */
0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0, /* 0x40 - 0x47 */
0, 0, 0, 0, 0, 0, 0, 0, /* 0x48 - 0x4f */
0, 0, 0, 0, 0, 0, 0x56, 0x57, /* 0x50 - 0x57 */
0x58, 0, 0, 0, 0, 0, 0, 0, /* 0x58 - 0x5f */
0, 0, 0, 0, 0, 0, 0, 0, /* 0x60 - 0x67 */
0, 0, 0, 0, 0, 0, 0, 0, /* 0x68 - 0x6f */
0, 0, 0x69, 0x65, 0, 0, 0, 0, /* 0x70 - 0x77 */
0, 0, 0, 0, 0, 0, 0, 0, /* 0x78 - 0x7f */
};
static KeySym eascii_to_x[512] = {
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
XK_BackSpace, XK_Tab, XK_Linefeed, NoSymbol,
NoSymbol, XK_Return, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, XK_Escape,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
XK_space, XK_exclam, XK_quotedbl, XK_numbersign,
XK_dollar, XK_percent, XK_ampersand, XK_apostrophe,
XK_parenleft, XK_parenright, XK_asterisk, XK_plus,
XK_comma, XK_minus, XK_period, XK_slash,
XK_0, XK_1, XK_2, XK_3,
XK_4, XK_5, XK_6, XK_7,
XK_8, XK_9, XK_colon, XK_semicolon,
XK_less, XK_equal, XK_greater, XK_question,
XK_at, XK_A, XK_B, XK_C,
XK_D, XK_E, XK_F, XK_G,
XK_H, XK_I, XK_J, XK_K,
XK_L, XK_M, XK_N, XK_O,
XK_P, XK_Q, XK_R, XK_S,
XK_T, XK_U, XK_V, XK_W,
XK_X, XK_Y, XK_Z, XK_bracketleft,
XK_backslash, XK_bracketright,XK_asciicircum, XK_underscore,
XK_grave, XK_a, XK_b, XK_c,
XK_d, XK_e, XK_f, XK_g,
XK_h, XK_i, XK_j, XK_k,
XK_l, XK_m, XK_n, XK_o,
XK_p, XK_q, XK_r, XK_s,
XK_t, XK_u, XK_v, XK_w,
XK_x, XK_y, XK_z, XK_braceleft,
XK_bar, XK_braceright, XK_asciitilde, XK_Delete,
XK_Ccedilla, XK_udiaeresis, XK_eacute, XK_acircumflex,
XK_adiaeresis, XK_agrave, XK_aring, XK_ccedilla,
XK_ecircumflex, XK_ediaeresis, XK_egrave, XK_idiaeresis,
XK_icircumflex, XK_igrave, XK_Adiaeresis, XK_Aring,
XK_Eacute, XK_ae, XK_AE, XK_ocircumflex,
XK_odiaeresis, XK_ograve, XK_ucircumflex, XK_ugrave,
XK_ydiaeresis, XK_Odiaeresis, XK_Udiaeresis, XK_cent,
XK_sterling, XK_yen, XK_paragraph, XK_section,
XK_aacute, XK_iacute, XK_oacute, XK_uacute,
XK_ntilde, XK_Ntilde, XK_ordfeminine, XK_masculine,
XK_questiondown,XK_hyphen, XK_notsign, XK_onehalf,
XK_onequarter, XK_exclamdown, XK_guillemotleft,XK_guillemotright,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
XK_Greek_alpha, XK_ssharp, XK_Greek_GAMMA, XK_Greek_pi,
XK_Greek_SIGMA, XK_Greek_sigma, XK_mu, XK_Greek_tau,
XK_Greek_PHI, XK_Greek_THETA, XK_Greek_OMEGA, XK_Greek_delta,
XK_infinity, XK_Ooblique, XK_Greek_epsilon, XK_intersection,
XK_identical, XK_plusminus, XK_greaterthanequal, XK_lessthanequal,
XK_topintegral, XK_botintegral, XK_division, XK_similarequal,
XK_degree, NoSymbol, NoSymbol, XK_radical,
XK_Greek_eta, XK_twosuperior, XK_periodcentered, NoSymbol,
/*
* special marked entries (256 + x)
*/
NoSymbol, NoSymbol, XK_Shift_L, XK_Shift_R,
XK_Caps_Lock, XK_Num_Lock, XK_Scroll_Lock, XK_Alt_L,
NoSymbol, XK_Control_L, XK_Alt_L, XK_Alt_R,
XK_Control_L, XK_Control_R, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, XK_F1,
XK_F2, XK_F3, XK_F4, XK_F5,
XK_F6, XK_F7, XK_F8, XK_F9,
XK_F10, XK_F11, XK_F12, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
};
#endif /* HAS_GETKEYMAP */
/*
* LegalModifier --
* determine whether a key is a legal modifier key, i.e send a
* press/release sequence.
*/
/*ARGSUSED*/
Bool
LegalModifier(key, pDev)
unsigned int key;
DevicePtr pDev;
{
return (TRUE);
}
/*
* xf86KbdGetMapping --
* Get the national keyboard mapping. The keyboard type is set, a new map
* and the modifiermap is computed.
*/
void
xf86KbdGetMapping (pKeySyms, pModMap)
KeySymsPtr pKeySyms;
CARD8 *pModMap;
{
KeySym *k;
#ifdef HAS_GETKEYMAP
keymap_t keymap;
#endif
int i;
KeySym *pMap;
#ifdef HAS_GETKBTYPE
char type;
xf86Info.kbdType =
ioctl(xf86Info.consoleFd, KDGKBTYPE, &type) != -1 ? type : KB_101;
if (xf86Info.kbdType == KB_84)
pMap = map84;
else
pMap = map;
#else
/* OS/2 sets the keyboard type during xf86OpenKbd */
#ifndef __UNIXOS2__
xf86Info.kbdType = 0;
#endif
pMap = map;
#endif
#ifdef HAS_GETKEYMAP
/*
* use the keymap, which can be gotten from our oringinal vt??.
* ( ttymap(1) !!!! )
*/
if (ioctl(xf86Info.consoleFd, GIO_KEYMAP, &keymap) != -1) {
for (i = 0; i < keymap.n_keys && i < NUM_KEYCODES; i++)
if (remap[i]) {
k = pMap + (remap[i] << 2);
k[0] = KD_GET_ENTRY(i,0); /* non-shifed */
k[1] = KD_GET_ENTRY(i,1); /* shifted */
k[2] = KD_GET_ENTRY(i,4); /* alt */
k[3] = KD_GET_ENTRY(i,5); /* alt - shifted */
if (k[3] == k[2]) k[3] = NoSymbol;
if (k[2] == k[1]) k[2] = NoSymbol;
if (k[1] == k[0]) k[1] = NoSymbol;
if (k[0] == k[2] && k[1] == k[3]) k[2] = k[3] = NoSymbol;
}
}
#endif
/*
* compute the modifier map
*/
for (i = 0; i < MAP_LENGTH; i++)
pModMap[i] = NoSymbol; /* make sure it is restored */
for (k = pMap, i = MIN_KEYCODE;
i < (NUM_KEYCODES + MIN_KEYCODE);
i++, k += 4)
switch(*k) {
case XK_Shift_L:
case XK_Shift_R:
pModMap[i] = ShiftMask;
break;
case XK_Control_L:
case XK_Control_R:
pModMap[i] = ControlMask;
break;
case XK_Caps_Lock:
pModMap[i] = LockMask;
break;
case XK_Alt_L:
case XK_Alt_R:
pModMap[i] = AltMask;
break;
case XK_Num_Lock:
pModMap[i] = NumLockMask;
break;
case XK_Scroll_Lock:
pModMap[i] = ScrollLockMask;
break;
/* kana support */
case XK_Kana_Lock:
case XK_Kana_Shift:
pModMap[i] = KanaMask;
break;
/* alternate toggle for multinational support */
case XK_Mode_switch:
pModMap[i] = AltLangMask;
break;
}
pKeySyms->map = pMap;
pKeySyms->mapWidth = GLYPHS_PER_KEY;
pKeySyms->minKeyCode = MIN_KEYCODE;
pKeySyms->maxKeyCode = MAX_KEYCODE;
}

1265
hw/xfree86/common/xf86KbdBSD.c
View File

File diff suppressed because it is too large Load Diff

650
hw/xfree86/common/xf86KbdLnx.c
View File

@ -1,650 +0,0 @@
/*
* Linux version of keymapping setup. The kernel (since 0.99.14) has support
* for fully remapping the keyboard, but there are some differences between
* the Linux map and the SVR4 map (esp. in the extended keycodes). We also
* remove the restriction on what keycodes can be remapped.
* Orest Zborowski.
*/
/*
* Copyright 1990,91 by Thomas Roell, Dinkelscherben, Germany.
*
* Permission to use, copy, modify, distribute, and sell this software and its
* documentation for any purpose is hereby granted without fee, provided that
* the above copyright notice appear in all copies and that both that
* copyright notice and this permission notice appear in supporting
* documentation, and that the name of Thomas Roell not be used in
* advertising or publicity pertaining to distribution of the software without
* specific, written prior permission. Thomas Roell makes no representations
* about the suitability of this software for any purpose. It is provided
* "as is" without express or implied warranty.
*
* THOMAS ROELL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
* EVENT SHALL THOMAS ROELL BE LIABLE FOR ANY SPECIAL, INDIRECT OR
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*
*/
/*
* Copyright (c) 1994-2001 by The XFree86 Project, Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*
* Except as contained in this notice, the name of the copyright holder(s)
* and author(s) shall not be used in advertising or otherwise to promote
* the sale, use or other dealings in this Software without prior written
* authorization from the copyright holder(s) and author(s).
*/
/* $XConsortium: xf86KbdLnx.c /main/7 1996/10/19 17:59:00 kaleb $ */
#ifdef HAVE_XORG_CONFIG_H
#include <xorg-config.h>
#endif
#include <X11/X.h>
#include <X11/Xmd.h>
#include "input.h"
#include "scrnintstr.h"
#include "compiler.h"
#include "xf86.h"
#include "xf86Priv.h"
#include "xf86_OSlib.h"
#include "atKeynames.h"
#include "xf86Keymap.h"
/*
* LegalModifier --
* determine whether a key is a legal modifier key, i.e send a
* press/release sequence.
*/
/*ARGSUSED*/
Bool
LegalModifier(unsigned int key, DevicePtr pDev)
{
return (TRUE);
}
/*
* xf86KbdGetMapping --
* Get the national keyboard mapping. The keyboard type is set, a new map
* and the modifiermap is computed.
*/
static void readKernelMapping(KeySymsPtr pKeySyms, CARD8 *pModMap);
void
xf86KbdGetMapping (KeySymsPtr pKeySyms, CARD8 *pModMap)
{
KeySym *k;
char type;
int i;
readKernelMapping(pKeySyms, pModMap);
/*
* compute the modifier map
*/
for (i = 0; i < MAP_LENGTH; i++)
pModMap[i] = NoSymbol; /* make sure it is restored */
for (k = map, i = MIN_KEYCODE;
i < (NUM_KEYCODES + MIN_KEYCODE);
i++, k += 4)
switch(*k) {
case XK_Shift_L:
case XK_Shift_R:
pModMap[i] = ShiftMask;
break;
case XK_Control_L:
case XK_Control_R:
pModMap[i] = ControlMask;
break;
case XK_Caps_Lock:
pModMap[i] = LockMask;
break;
case XK_Alt_L:
case XK_Alt_R:
pModMap[i] = AltMask;
break;
case XK_Num_Lock:
pModMap[i] = NumLockMask;
break;
case XK_Scroll_Lock:
pModMap[i] = ScrollLockMask;
break;
/* kana support */
case XK_Kana_Lock:
case XK_Kana_Shift:
pModMap[i] = KanaMask;
break;
/* alternate toggle for multinational support */
case XK_Mode_switch:
pModMap[i] = AltLangMask;
break;
}
xf86Info.kbdType =
ioctl(xf86Info.consoleFd, KDGKBTYPE, &type) != -1 ? type : KB_101;
pKeySyms->map = map;
pKeySyms->mapWidth = GLYPHS_PER_KEY;
pKeySyms->minKeyCode = MIN_KEYCODE;
pKeySyms->maxKeyCode = MAX_KEYCODE;
}
#include <linux/keyboard.h>
static KeySym linux_to_x[256] = {
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
XK_BackSpace, XK_Tab, XK_Linefeed, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, XK_Escape,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
XK_space, XK_exclam, XK_quotedbl, XK_numbersign,
XK_dollar, XK_percent, XK_ampersand, XK_apostrophe,
XK_parenleft, XK_parenright, XK_asterisk, XK_plus,
XK_comma, XK_minus, XK_period, XK_slash,
XK_0, XK_1, XK_2, XK_3,
XK_4, XK_5, XK_6, XK_7,
XK_8, XK_9, XK_colon, XK_semicolon,
XK_less, XK_equal, XK_greater, XK_question,
XK_at, XK_A, XK_B, XK_C,
XK_D, XK_E, XK_F, XK_G,
XK_H, XK_I, XK_J, XK_K,
XK_L, XK_M, XK_N, XK_O,
XK_P, XK_Q, XK_R, XK_S,
XK_T, XK_U, XK_V, XK_W,
XK_X, XK_Y, XK_Z, XK_bracketleft,
XK_backslash, XK_bracketright,XK_asciicircum, XK_underscore,
XK_grave, XK_a, XK_b, XK_c,
XK_d, XK_e, XK_f, XK_g,
XK_h, XK_i, XK_j, XK_k,
XK_l, XK_m, XK_n, XK_o,
XK_p, XK_q, XK_r, XK_s,
XK_t, XK_u, XK_v, XK_w,
XK_x, XK_y, XK_z, XK_braceleft,
XK_bar, XK_braceright, XK_asciitilde, XK_BackSpace,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
XK_nobreakspace,XK_exclamdown, XK_cent, XK_sterling,
XK_currency, XK_yen, XK_brokenbar, XK_section,
XK_diaeresis, XK_copyright, XK_ordfeminine, XK_guillemotleft,
XK_notsign, XK_hyphen, XK_registered, XK_macron,
XK_degree, XK_plusminus, XK_twosuperior, XK_threesuperior,
XK_acute, XK_mu, XK_paragraph, XK_periodcentered,
XK_cedilla, XK_onesuperior, XK_masculine, XK_guillemotright,
XK_onequarter, XK_onehalf, XK_threequarters,XK_questiondown,
XK_Agrave, XK_Aacute, XK_Acircumflex, XK_Atilde,
XK_Adiaeresis, XK_Aring, XK_AE, XK_Ccedilla,
XK_Egrave, XK_Eacute, XK_Ecircumflex, XK_Ediaeresis,
XK_Igrave, XK_Iacute, XK_Icircumflex, XK_Idiaeresis,
XK_ETH, XK_Ntilde, XK_Ograve, XK_Oacute,
XK_Ocircumflex, XK_Otilde, XK_Odiaeresis, XK_multiply,
XK_Ooblique, XK_Ugrave, XK_Uacute, XK_Ucircumflex,
XK_Udiaeresis, XK_Yacute, XK_THORN, XK_ssharp,
XK_agrave, XK_aacute, XK_acircumflex, XK_atilde,
XK_adiaeresis, XK_aring, XK_ae, XK_ccedilla,
XK_egrave, XK_eacute, XK_ecircumflex, XK_ediaeresis,
XK_igrave, XK_iacute, XK_icircumflex, XK_idiaeresis,
XK_eth, XK_ntilde, XK_ograve, XK_oacute,
XK_ocircumflex, XK_otilde, XK_odiaeresis, XK_division,
XK_oslash, XK_ugrave, XK_uacute, XK_ucircumflex,
XK_udiaeresis, XK_yacute, XK_thorn, XK_ydiaeresis
};
/*
* Maps the AT keycodes to Linux keycodes
*/
static unsigned char at2lnx[NUM_KEYCODES] =
{
0x01, /* KEY_Escape */ 0x02, /* KEY_1 */
0x03, /* KEY_2 */ 0x04, /* KEY_3 */
0x05, /* KEY_4 */ 0x06, /* KEY_5 */
0x07, /* KEY_6 */ 0x08, /* KEY_7 */
0x09, /* KEY_8 */ 0x0a, /* KEY_9 */
0x0b, /* KEY_0 */ 0x0c, /* KEY_Minus */
0x0d, /* KEY_Equal */ 0x0e, /* KEY_BackSpace */
0x0f, /* KEY_Tab */ 0x10, /* KEY_Q */
0x11, /* KEY_W */ 0x12, /* KEY_E */
0x13, /* KEY_R */ 0x14, /* KEY_T */
0x15, /* KEY_Y */ 0x16, /* KEY_U */
0x17, /* KEY_I */ 0x18, /* KEY_O */
0x19, /* KEY_P */ 0x1a, /* KEY_LBrace */
0x1b, /* KEY_RBrace */ 0x1c, /* KEY_Enter */
0x1d, /* KEY_LCtrl */ 0x1e, /* KEY_A */
0x1f, /* KEY_S */ 0x20, /* KEY_D */
0x21, /* KEY_F */ 0x22, /* KEY_G */
0x23, /* KEY_H */ 0x24, /* KEY_J */
0x25, /* KEY_K */ 0x26, /* KEY_L */
0x27, /* KEY_SemiColon */ 0x28, /* KEY_Quote */
0x29, /* KEY_Tilde */ 0x2a, /* KEY_ShiftL */
0x2b, /* KEY_BSlash */ 0x2c, /* KEY_Z */
0x2d, /* KEY_X */ 0x2e, /* KEY_C */
0x2f, /* KEY_V */ 0x30, /* KEY_B */
0x31, /* KEY_N */ 0x32, /* KEY_M */
0x33, /* KEY_Comma */ 0x34, /* KEY_Period */
0x35, /* KEY_Slash */ 0x36, /* KEY_ShiftR */
0x37, /* KEY_KP_Multiply */ 0x38, /* KEY_Alt */
0x39, /* KEY_Space */ 0x3a, /* KEY_CapsLock */
0x3b, /* KEY_F1 */ 0x3c, /* KEY_F2 */
0x3d, /* KEY_F3 */ 0x3e, /* KEY_F4 */
0x3f, /* KEY_F5 */ 0x40, /* KEY_F6 */
0x41, /* KEY_F7 */ 0x42, /* KEY_F8 */
0x43, /* KEY_F9 */ 0x44, /* KEY_F10 */
0x45, /* KEY_NumLock */ 0x46, /* KEY_ScrollLock */
0x47, /* KEY_KP_7 */ 0x48, /* KEY_KP_8 */
0x49, /* KEY_KP_9 */ 0x4a, /* KEY_KP_Minus */
0x4b, /* KEY_KP_4 */ 0x4c, /* KEY_KP_5 */
0x4d, /* KEY_KP_6 */ 0x4e, /* KEY_KP_Plus */
0x4f, /* KEY_KP_1 */ 0x50, /* KEY_KP_2 */
0x51, /* KEY_KP_3 */ 0x52, /* KEY_KP_0 */
0x53, /* KEY_KP_Decimal */ 0x54, /* KEY_SysReqest */
0x00, /* 0x55 */ 0x56, /* KEY_Less */
0x57, /* KEY_F11 */ 0x58, /* KEY_F12 */
0x66, /* KEY_Home */ 0x67, /* KEY_Up */
0x68, /* KEY_PgUp */ 0x69, /* KEY_Left */
0x5d, /* KEY_Begin */ 0x6a, /* KEY_Right */
0x6b, /* KEY_End */ 0x6c, /* KEY_Down */
0x6d, /* KEY_PgDown */ 0x6e, /* KEY_Insert */
0x6f, /* KEY_Delete */ 0x60, /* KEY_KP_Enter */
0x61, /* KEY_RCtrl */ 0x77, /* KEY_Pause */
0x63, /* KEY_Print */ 0x62, /* KEY_KP_Divide */
0x64, /* KEY_AltLang */ 0x65, /* KEY_Break */
0x00, /* KEY_LMeta */ 0x00, /* KEY_RMeta */
0x7A, /* KEY_Menu/FOCUS_PF11*/0x00, /* 0x6e */
0x7B, /* FOCUS_PF12 */ 0x00, /* 0x70 */
0x00, /* 0x71 */ 0x00, /* 0x72 */
0x59, /* FOCUS_PF2 */ 0x78, /* FOCUS_PF9 */
0x00, /* 0x75 */ 0x00, /* 0x76 */
0x5A, /* FOCUS_PF3 */ 0x5B, /* FOCUS_PF4 */
0x5C, /* FOCUS_PF5 */ 0x5D, /* FOCUS_PF6 */
0x5E, /* FOCUS_PF7 */ 0x5F, /* FOCUS_PF8 */
0x7C, /* JAP_86 */ 0x79, /* FOCUS_PF10 */
0x00, /* 0x7f */
};
#define NUM_AT2LNX (sizeof(at2lnx) / sizeof(at2lnx[0]))
#define NUM_CUSTOMKEYS NR_KEYS
u_char SpecialServerMap[NUM_CUSTOMKEYS];
static void
readKernelMapping(KeySymsPtr pKeySyms, CARD8 *pModMap)
{
KeySym *k;
int i;
int maxkey;
static unsigned char tbl[GLYPHS_PER_KEY] =
{
0, /* unshifted */
1, /* shifted */
0, /* modeswitch unshifted */
0 /* modeswitch shifted */
};
/*
* Read the mapping from the kernel.
* Since we're still using the XFree86 scancode->AT keycode mapping
* routines, we need to convert the AT keycodes to Linux keycodes,
* then translate the Linux keysyms into X keysyms.
*
* First, figure out which tables to use for the modeswitch columns
* above, from the XF86Config fields.
*/
tbl[2] = 8; /* alt */
tbl[3] = tbl[2] | 1;
if (xf86Info.kbdCustomKeycodes) {
k = map;
maxkey = NUM_CUSTOMKEYS;
}
else {
k = map+GLYPHS_PER_KEY;
maxkey = NUM_AT2LNX;
}
for (i = 0; i < maxkey; ++i)
{
struct kbentry kbe;
int j;
if (xf86Info.kbdCustomKeycodes)
kbe.kb_index = i;
else
kbe.kb_index = at2lnx[i];
for (j = 0; j < GLYPHS_PER_KEY; ++j, ++k)
{
unsigned short kval;
*k = NoSymbol;
kbe.kb_table = tbl[j];
if (
(!xf86Info.kbdCustomKeycodes && kbe.kb_index == 0) ||
ioctl(xf86Info.consoleFd, KDGKBENT, &kbe))
continue;
kval = KVAL(kbe.kb_value);
switch (KTYP(kbe.kb_value))
{
case KT_LATIN:
case KT_LETTER:
*k = linux_to_x[kval];
break;
case KT_FN:
if (kval <= 19)
*k = XK_F1 + kval;
else switch (kbe.kb_value)
{
case K_FIND:
*k = XK_Home; /* or XK_Find */
break;
case K_INSERT:
*k = XK_Insert;
break;
case K_REMOVE:
*k = XK_Delete;
break;
case K_SELECT:
*k = XK_End; /* or XK_Select */
break;
case K_PGUP:
*k = XK_Prior;
break;
case K_PGDN:
*k = XK_Next;
break;
case K_HELP:
*k = XK_Help;
break;
case K_DO:
*k = XK_Execute;
break;
case K_PAUSE:
*k = XK_Pause;
break;
case K_MACRO:
*k = XK_Menu;
break;
default:
break;
}
break;
case KT_SPEC:
switch (kbe.kb_value)
{
case K_ENTER:
*k = XK_Return;
break;
case K_BREAK:
*k = XK_Break;
break;
case K_CAPS:
*k = XK_Caps_Lock;
break;
case K_NUM:
*k = XK_Num_Lock;
break;
case K_HOLD:
*k = XK_Scroll_Lock;
break;
case K_COMPOSE:
*k = XK_Multi_key;
break;
default:
break;
}
break;
case KT_PAD:
switch (kbe.kb_value)
{
case K_PPLUS:
*k = XK_KP_Add;
break;
case K_PMINUS:
*k = XK_KP_Subtract;
break;
case K_PSTAR:
*k = XK_KP_Multiply;
break;
case K_PSLASH:
*k = XK_KP_Divide;
break;
case K_PENTER:
*k = XK_KP_Enter;
break;
case K_PCOMMA:
*k = XK_KP_Separator;
break;
case K_PDOT:
*k = XK_KP_Decimal;
break;
case K_PPLUSMINUS:
*k = XK_KP_Subtract;
break;
default:
if (kval <= 9)
*k = XK_KP_0 + kval;
break;
}
break;
/*
* KT_DEAD keys are for accelerated diacritical creation.
*/
case KT_DEAD:
switch (kbe.kb_value)
{
case K_DGRAVE:
*k = XK_dead_grave;
break;
case K_DACUTE:
*k = XK_dead_acute;
break;
case K_DCIRCM:
*k = XK_dead_circumflex;
break;
case K_DTILDE:
*k = XK_dead_tilde;
break;
case K_DDIERE:
*k = XK_dead_diaeresis;
break;
}
break;
case KT_CUR:
switch (kbe.kb_value)
{
case K_DOWN:
*k = XK_Down;
break;
case K_LEFT:
*k = XK_Left;
break;
case K_RIGHT:
*k = XK_Right;
break;
case K_UP:
*k = XK_Up;
break;
}
break;
case KT_SHIFT:
switch (kbe.kb_value)
{
case K_ALTGR:
*k = XK_Alt_R;
break;
case K_ALT:
*k = (kbe.kb_index == 0x64 ?
XK_Alt_R : XK_Alt_L);
break;
case K_CTRL:
*k = (kbe.kb_index == 0x61 ?
XK_Control_R : XK_Control_L);
break;
case K_CTRLL:
*k = XK_Control_L;
break;
case K_CTRLR:
*k = XK_Control_R;
break;
case K_SHIFT:
*k = (kbe.kb_index == 0x36 ?
XK_Shift_R : XK_Shift_L);
break;
case K_SHIFTL:
*k = XK_Shift_L;
break;
case K_SHIFTR:
*k = XK_Shift_R;
break;
default:
break;
}
break;
/*
* KT_ASCII keys accumulate a 3 digit decimal number that gets
* emitted when the shift state changes. We can't emulate that.
*/
case KT_ASCII:
break;
case KT_LOCK:
if (kbe.kb_value == K_SHIFTLOCK)
*k = XK_Shift_Lock;
break;
default:
break;
}
}
if (k[-1] == k[-2]) k[-1] = NoSymbol;
if (k[-2] == k[-3]) k[-2] = NoSymbol;
if (k[-3] == k[-4]) k[-3] = NoSymbol;
if (k[-4] == k[-2] && k[-3] == k[-1]) k[-2] = k[-1] = NoSymbol;
if (k[-1] == k[-4] && k[-2] == k[-3] && k[-2] == NoSymbol) k[-1] =NoSymbol;
}
if (!xf86Info.kbdCustomKeycodes)
return;
/*
* Find the Mapping for the special server functions
*/
for (i = 0; i < NUM_CUSTOMKEYS; ++i) {
struct kbentry kbe;
int special = 0;
kbe.kb_index = i;
kbe.kb_table = 0; /* Plain map */
if (!ioctl(xf86Info.consoleFd, KDGKBENT, &kbe))
switch (kbe.kb_value) {
case K(KT_LATIN,0x7f): /* This catches DEL too... But who cares? */
special = KEY_BackSpace;
break;
case K_PMINUS:
special = KEY_KP_Minus;
break;
case K_PPLUS:
special = KEY_KP_Plus;
break;
case K_F1:
special = KEY_F1;
break;
case K_F2:
special = KEY_F2;
break;
case K_F3:
special = KEY_F3;
break;
case K_F4:
special = KEY_F4;
break;
case K_F5:
special = KEY_F5;
break;
case K_F6:
special = KEY_F6;
break;
case K_F7:
special = KEY_F7;
break;
case K_F8:
special = KEY_F8;
break;
case K_F9:
special = KEY_F9;
break;
case K_F10:
special = KEY_F10;
break;
case K_F11:
special = KEY_F11;
break;
case K_F12:
special = KEY_F12;
break;
case K_ALT:
special = KEY_Alt;
break;
case K_ALTGR:
special = KEY_AltLang;
break;
case K_CONS:
special = KEY_SysReqest;
break;
}
SpecialServerMap[i] = special;
}
}

316
hw/xfree86/common/xf86KbdMach.c
View File

@ -1,316 +0,0 @@
/*
*****************************************************************************
* HISTORY
* Log: xf86KbdMach.c,v
* Revision 2.1.2.1 92/06/25 10:32:08 moore
* Incorporate the Elliot Dresselhaus's, Ernest Hua's and local changes
* to run Thomas Roell's I386 color X11R5. Original code only worked
* with SCO Unix. New code works with 2.5 and 3.0 Mach
* [92/06/24 rvb]
*
* EndLog
*
*****************************************************************************
*/
/*
* Copyright 1990,91 by Thomas Roell, Dinkelscherben, Germany.
*
* Permission to use, copy, modify, distribute, and sell this software and its
* documentation for any purpose is hereby granted without fee, provided that
* the above copyright notice appear in all copies and that both that
* copyright notice and this permission notice appear in supporting
* documentation, and that the name of Thomas Roell not be used in
* advertising or publicity pertaining to distribution of the software without
* specific, written prior permission. Thomas Roell makes no representations
* about the suitability of this software for any purpose. It is provided
* "as is" without express or implied warranty.
*
* THOMAS ROELL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
* EVENT SHALL THOMAS ROELL BE LIABLE FOR ANY SPECIAL, INDIRECT OR
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*
*/
/* $XConsortium: xf86KbdMach.c /main/9 1996/02/21 17:38:43 kaleb $ */
#ifdef HAVE_XORG_CONFIG_H
#include <xorg-config.h>
#endif
#include <X11/X.h>
#include <X11/Xmd.h>
#include "input.h"
#include "scrnintstr.h"
#include "compiler.h"
#include "xf86.h"
#include "xf86Priv.h"
#include "xf86_OSlib.h"
#include "atKeynames.h"
#include "xf86Config.h"
#include "xf86Keymap.h"
static KeySym ascii_to_x[256] = {
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
XK_BackSpace, XK_Tab, XK_Linefeed, NoSymbol,
NoSymbol, XK_Return, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, XK_Escape,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
XK_space, XK_exclam, XK_quotedbl, XK_numbersign,
XK_dollar, XK_percent, XK_ampersand, XK_apostrophe,
XK_parenleft, XK_parenright, XK_asterisk, XK_plus,
XK_comma, XK_minus, XK_period, XK_slash,
XK_0, XK_1, XK_2, XK_3,
XK_4, XK_5, XK_6, XK_7,
XK_8, XK_9, XK_colon, XK_semicolon,
XK_less, XK_equal, XK_greater, XK_question,
XK_at, XK_A, XK_B, XK_C,
XK_D, XK_E, XK_F, XK_G,
XK_H, XK_I, XK_J, XK_K,
XK_L, XK_M, XK_N, XK_O,
XK_P, XK_Q, XK_R, XK_S,
XK_T, XK_U, XK_V, XK_W,
XK_X, XK_Y, XK_Z, XK_bracketleft,
XK_backslash, XK_bracketright,XK_asciicircum, XK_underscore,
XK_grave, XK_a, XK_b, XK_c,
XK_d, XK_e, XK_f, XK_g,
XK_h, XK_i, XK_j, XK_k,
XK_l, XK_m, XK_n, XK_o,
XK_p, XK_q, XK_r, XK_s,
XK_t, XK_u, XK_v, XK_w,
XK_x, XK_y, XK_z, XK_braceleft,
XK_bar, XK_braceright, XK_asciitilde, XK_Delete,
XK_Ccedilla, XK_udiaeresis, XK_eacute, XK_acircumflex,
XK_adiaeresis, XK_agrave, XK_aring, XK_ccedilla,
XK_ecircumflex, XK_ediaeresis, XK_egrave, XK_idiaeresis,
XK_icircumflex, XK_igrave, XK_Adiaeresis, XK_Aring,
XK_Eacute, XK_ae, XK_AE, XK_ocircumflex,
XK_odiaeresis, XK_ograve, XK_ucircumflex, XK_ugrave,
XK_ydiaeresis, XK_Odiaeresis, XK_Udiaeresis, XK_cent,
XK_sterling, XK_yen, XK_paragraph, XK_section,
XK_aacute, XK_iacute, XK_oacute, XK_uacute,
XK_ntilde, XK_Ntilde, XK_ordfeminine, XK_masculine,
XK_questiondown,XK_hyphen, XK_notsign, XK_onehalf,
XK_onequarter, XK_exclamdown, XK_guillemotleft,XK_guillemotright,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
XK_Greek_alpha, XK_ssharp, XK_Greek_GAMMA, XK_Greek_pi,
XK_Greek_SIGMA, XK_Greek_sigma, XK_mu, XK_Greek_tau,
XK_Greek_PHI, XK_Greek_THETA, XK_Greek_OMEGA, XK_Greek_delta,
XK_infinity, XK_Ooblique, XK_Greek_epsilon, XK_intersection,
XK_identical, XK_plusminus, XK_greaterthanequal, XK_lessthanequal,
XK_topintegral, XK_botintegral, XK_division, XK_similarequal,
XK_degree, NoSymbol, NoSymbol, XK_radical,
XK_Greek_eta, XK_twosuperior, XK_periodcentered, NoSymbol,
};
/*
* LegalModifier --
* determine whether a key is a legal modifier key, i.e send a
* press/release sequence.
*/
/*ARGSUSED*/
Bool
LegalModifier(key, pDev)
unsigned int key;
DevicePtr pDev;
{
return (TRUE);
}
/*
* xf86KbdGetMapping --
* Get the national keyboard mapping. The keyboard type is set, a new map
* and the modifiermap is computed.
*/
void
xf86KbdGetMapping (pKeySyms, pModMap)
KeySymsPtr pKeySyms;
CARD8 *pModMap;
{
KeySym *k;
struct kbentry kbe;
char type;
int i, j;
for (i = 0; i < NUMKEYS; i++)
{
static int states[] = { NORM_STATE, SHIFT_STATE, ALT_STATE, SHIFT_ALT };
int j;
k = &map[i*4];
kbe.kb_index = i;
for (j = 0; j < 4; j++)
{
kbe.kb_state = states[j];
if (ioctl (xf86Info.consoleFd, KDGKBENT, &kbe) != -1)
continue;
if (kbe.kb_value [0] == K_SCAN)
{
int keycode = -1;
switch (kbe.kb_value [1])
{
case K_CTLSC: keycode = XK_Control_L; break;
case K_LSHSC: keycode = XK_Shift_L; break;
case K_RSHSC: keycode = XK_Shift_R; break;
case K_ALTSC: keycode = XK_Alt_L; break;
case K_CLCKSC: keycode = XK_Caps_Lock; break;
case K_NLCKSC: keycode = XK_Num_Lock; break;
default: break;
}
if (keycode > 0)
k[j] = keycode;
}
else if (kbe.kb_value[1] != NC)
{
/* How to handle multiple characters?
Ignore them for now. */
}
else
{
k[j] = ascii_to_x[kbe.kb_value[0]];
}
}
}
/*
* Apply the special key mapping specified in XF86Config
*/
for (k = map, i = MIN_KEYCODE;
i < (NUM_KEYCODES + MIN_KEYCODE);
i++, k += 4) {
switch (k[0]) {
case XK_Alt_L:
j = K_INDEX_LEFTALT;
break;
case XK_Alt_R:
j = K_INDEX_RIGHTALT;
break;
case XK_Scroll_Lock:
j = K_INDEX_SCROLLLOCK;
break;
case XK_Control_R:
j = K_INDEX_RIGHTCTL;
break;
default:
j = -1;
}
if (j >= 0)
switch (xf86Info.specialKeyMap[j]) {
case KM_META:
if (k[0] == XK_Alt_R)
k[1] = XK_Meta_R;
else {
k[0] = XK_Alt_L;
k[1] = XK_Meta_L;
}
break;
case KM_COMPOSE:
k[0] = XK_Multi_key;
break;
case KM_MODESHIFT:
k[0] = XK_Mode_switch;
k[1] = NoSymbol;
break;
case KM_MODELOCK:
k[0] = XK_Mode_switch;
k[1] = XF86XK_ModeLock;
break;
case KM_SCROLLLOCK:
k[0] = XK_Scroll_Lock;
break;
case KM_CONTROL:
k[0] = XK_Control_R;
break;
}
}
/*
* compute the modifier map
*/
for (i = 0; i < MAP_LENGTH; i++)
pModMap[i] = NoSymbol; /* make sure it is restored */
for (k = map, i = MIN_KEYCODE;
i < (NUM_KEYCODES + MIN_KEYCODE);
i++, k += 4)
switch(*k) {
case XK_Shift_L:
case XK_Shift_R:
pModMap[i] = ShiftMask;
break;
case XK_Control_L:
case XK_Control_R:
pModMap[i] = ControlMask;
break;
case XK_Caps_Lock:
pModMap[i] = LockMask;
break;
case XK_Alt_L:
case XK_Alt_R:
pModMap[i] = AltMask;
break;
case XK_Num_Lock:
if (!xf86Info.serverNumLock) pModMap[i] = NumLockMask;
break;
case XK_Scroll_Lock:
pModMap[i] = ScrollLockMask;
break;
/* kana support */
case XK_Kana_Lock:
case XK_Kana_Shift:
pModMap[i] = KanaMask;
break;
/* alternate toggle for multinational support */
case XK_Mode_switch:
pModMap[i] = AltLangMask;
break;
}
xf86Info.kbdType =
ioctl(xf86Info.kbdFd, KDGKBDTYPE, &type) != -1 ? type : KB_VANILLAKB;
pKeySyms->map = map;
pKeySyms->mapWidth = GLYPHS_PER_KEY;
pKeySyms->minKeyCode = MIN_KEYCODE;
if (xf86Info.serverNumLock)
pKeySyms->maxKeyCode = MAX_KEYCODE;
else
pKeySyms->maxKeyCode = MAX_STD_KEYCODE;
}

530
hw/xfree86/os-support/linux/lnx_kbd.c
View File

@ -1,530 +0,0 @@
/*
* Copyright (c) 2002 by The XFree86 Project, Inc.
* Author: Ivan Pascal.
*
* Based on the code from lnx_io.c which is
* Copyright 1992 by Orest Zborowski <obz@Kodak.com>
* Copyright 1993 by David Dawes <dawes@xfree86.org>
*/
#define NEED_EVENTS
#ifdef HAVE_XORG_CONFIG_H
#include <xorg-config.h>
#endif
#include <X11/X.h>
#include "compiler.h"
#include "xf86.h"
#include "xf86Priv.h"
#include "xf86_OSlib.h"
#include "xf86Xinput.h"
#include "xf86OSKbd.h"
#include "atKeynames.h"
#if defined(DO_OS_FONTRESTORE)
#include "lnx.h"
#endif
#include "lnx_kbd.h"
#define KBC_TIMEOUT 250 /* Timeout in ms for sending to keyboard controller */
static KbdProtocolRec protocols[] = {
{"standard", PROT_STD },
{ NULL, PROT_UNKNOWN_KBD }
};
extern Bool VTSwitchEnabled;
#ifdef USE_VT_SYSREQ
extern Bool VTSysreqToggle;
#endif
static void
SoundBell(InputInfoPtr pInfo, int loudness, int pitch, int duration)
{
if (loudness && pitch)
{
ioctl(pInfo->fd, KDMKTONE,
((1193190 / pitch) & 0xffff) |
(((unsigned long)duration *
loudness / 50) << 16));
}
}
static void
SetKbdLeds(InputInfoPtr pInfo, int leds)
{
int real_leds = 0;
#if defined (__sparc__)
KbdDevPtr pKbd = (KbdDevPtr) pInfo->private;
if (pKbd->sunKbd) {
if (leds & 0x08) real_leds |= XLED1;
if (leds & 0x04) real_leds |= XLED3;
if (leds & 0x02) real_leds |= XLED4;
if (leds & 0x01) real_leds |= XLED2;
leds = real_leds;
real_leds = 0;
}
#endif /* defined (__sparc__) */
#ifdef LED_CAP
if (leds & XLED1) real_leds |= LED_CAP;
if (leds & XLED2) real_leds |= LED_NUM;
if (leds & XLED3) real_leds |= LED_SCR;
#ifdef LED_COMP
if (leds & XLED4) real_leds |= LED_COMP;
#else
if (leds & XLED4) real_leds |= LED_SCR;
#endif
#endif
ioctl(pInfo->fd, KDSETLED, real_leds);
}
static int
GetKbdLeds(InputInfoPtr pInfo)
{
int real_leds, leds = 0;
ioctl(pInfo->fd, KDGETLED, &real_leds);
if (real_leds & LED_CAP) leds |= XLED1;
if (real_leds & LED_NUM) leds |= XLED2;
if (real_leds & LED_SCR) leds |= XLED3;
return(leds);
}
static int
KDKBDREP_ioctl_ok(int rate, int delay) {
#if defined(KDKBDREP) && !defined(__sparc__)
/* This ioctl is defined in <linux/kd.h> but is not
implemented anywhere - must be in some m68k patches. */
struct kbd_repeat kbdrep_s;
/* don't change, just test */
kbdrep_s.LNX_KBD_PERIOD_NAME = -1;
kbdrep_s.delay = -1;
if (ioctl( xf86Info.consoleFd, KDKBDREP, &kbdrep_s )) {
return 0;
}
/* do the change */
if (rate == 0) /* switch repeat off */
kbdrep_s.LNX_KBD_PERIOD_NAME = 0;
else
kbdrep_s.LNX_KBD_PERIOD_NAME = 10000 / rate; /* convert cps to msec */
if (kbdrep_s.LNX_KBD_PERIOD_NAME < 1)
kbdrep_s.LNX_KBD_PERIOD_NAME = 1;
kbdrep_s.delay = delay;
if (kbdrep_s.delay < 1)
kbdrep_s.delay = 1;
if (ioctl( xf86Info.consoleFd, KDKBDREP, &kbdrep_s )) {
return 0;
}
return 1; /* success! */
#else /* no KDKBDREP */
return 0;
#endif /* KDKBDREP */
}
static int
KIOCSRATE_ioctl_ok(int rate, int delay) {
#ifdef KIOCSRATE
struct kbd_rate kbdrate_s;
int fd;
fd = open("/dev/kbd", O_RDONLY);
if (fd == -1)
return 0;
kbdrate_s.rate = (rate + 5) / 10; /* must be integer, so round up */
kbdrate_s.delay = delay * HZ / 1000; /* convert ms to Hz */
if (kbdrate_s.rate > 50)
kbdrate_s.rate = 50;
if (ioctl( fd, KIOCSRATE, &kbdrate_s )) {
return 0;
}
close( fd );
return 1;
#else /* no KIOCSRATE */
return 0;
#endif /* KIOCSRATE */
}
#undef rate
static void
SetKbdRepeat(InputInfoPtr pInfo, char rad)
{
KbdDevPtr pKbd = (KbdDevPtr) pInfo->private;
int i;
int timeout;
int value = 0x7f; /* Maximum delay with slowest rate */
#ifdef __sparc__
int rate = 500; /* Default rate */
int delay = 200; /* Default delay */
#else
int rate = 300; /* Default rate */
int delay = 250; /* Default delay */
#endif
static int valid_rates[] = { 300, 267, 240, 218, 200, 185, 171, 160, 150,
133, 120, 109, 100, 92, 86, 80, 75, 67,
60, 55, 50, 46, 43, 40, 37, 33, 30, 27,
25, 23, 21, 20 };
#define RATE_COUNT (sizeof( valid_rates ) / sizeof( int ))
static int valid_delays[] = { 250, 500, 750, 1000 };
#define DELAY_COUNT (sizeof( valid_delays ) / sizeof( int ))
if (pKbd->rate >= 0)
rate = pKbd->rate * 10;
if (pKbd->delay >= 0)
delay = pKbd->delay;
if(KDKBDREP_ioctl_ok(rate, delay)) /* m68k? */
return;
if(KIOCSRATE_ioctl_ok(rate, delay)) /* sparc? */
return;
if (xf86IsPc98())
return;
#if defined(__alpha__) || defined (__i386__) || defined(__ia64__)
if (!xorgHWAccess) {
if (xf86EnableIO())
xorgHWAccess = TRUE;
else
return;
}
/* The ioport way */
for (i = 0; i < RATE_COUNT; i++)
if (rate >= valid_rates[i]) {
value &= 0x60;
value |= i;
break;
}
for (i = 0; i < DELAY_COUNT; i++)
if (delay <= valid_delays[i]) {
value &= 0x1f;
value |= i << 5;
break;
}
timeout = KBC_TIMEOUT;
while (((inb(0x64) & 2) == 2) && --timeout)
usleep(1000); /* wait */
if (timeout == 0)
return;
outb(0x60, 0xf3); /* set typematic rate */
while (((inb(0x64) & 2) == 2) && --timeout)
usleep(1000); /* wait */
usleep(10000);
outb(0x60, value);
#endif /* __alpha__ || __i386__ || __ia64__ */
}
typedef struct {
int kbdtrans;
struct termios kbdtty;
} LnxKbdPrivRec, *LnxKbdPrivPtr;
static int
KbdInit(InputInfoPtr pInfo, int what)
{
KbdDevPtr pKbd = (KbdDevPtr) pInfo->private;
LnxKbdPrivPtr priv = (LnxKbdPrivPtr) pKbd->private;
if (pKbd->isConsole) {
ioctl (pInfo->fd, KDGKBMODE, &(priv->kbdtrans));
tcgetattr (pInfo->fd, &(priv->kbdtty));
}
if (!pKbd->CustomKeycodes) {
pKbd->RemapScanCode = ATScancode;
}
return Success;
}
static int
KbdOn(InputInfoPtr pInfo, int what)
{
KbdDevPtr pKbd = (KbdDevPtr) pInfo->private;
LnxKbdPrivPtr priv = (LnxKbdPrivPtr) pKbd->private;
struct termios nTty;
if (pKbd->isConsole) {
if (pKbd->CustomKeycodes)
ioctl(pInfo->fd, KDSKBMODE, K_MEDIUMRAW);
else
ioctl(pInfo->fd, KDSKBMODE, K_RAW);
nTty = priv->kbdtty;
nTty.c_iflag = (IGNPAR | IGNBRK) & (~PARMRK) & (~ISTRIP);
nTty.c_oflag = 0;
nTty.c_cflag = CREAD | CS8;
nTty.c_lflag = 0;
nTty.c_cc[VTIME]=0;
nTty.c_cc[VMIN]=1;
cfsetispeed(&nTty, 9600);
cfsetospeed(&nTty, 9600);
tcsetattr(pInfo->fd, TCSANOW, &nTty);
}
return Success;
}
static int
KbdOff(InputInfoPtr pInfo, int what)
{
KbdDevPtr pKbd = (KbdDevPtr) pInfo->private;
LnxKbdPrivPtr priv = (LnxKbdPrivPtr) pKbd->private;
if (pKbd->isConsole) {
ioctl(pInfo->fd, KDSKBMODE, priv->kbdtrans);
tcsetattr(pInfo->fd, TCSANOW, &(priv->kbdtty));
}
return Success;
}
static int
GetSpecialKey(InputInfoPtr pInfo, int scanCode)
{
KbdDevPtr pKbd = (KbdDevPtr) pInfo->private;
int specialkey = scanCode;
#if defined (__sparc__)
if (pKbd->sunKbd) {
switch (scanCode) {
case 0x2b: specialkey = KEY_BackSpace; break;
case 0x47: specialkey = KEY_KP_Minus; break;
case 0x7d: specialkey = KEY_KP_Plus; break;
/* XXX needs cases for KEY_KP_Divide and KEY_KP_Multiply */
case 0x05: specialkey = KEY_F1; break;
case 0x06: specialkey = KEY_F2; break;
case 0x08: specialkey = KEY_F3; break;
case 0x0a: specialkey = KEY_F4; break;
case 0x0c: specialkey = KEY_F5; break;
case 0x0e: specialkey = KEY_F6; break;
case 0x10: specialkey = KEY_F7; break;
case 0x11: specialkey = KEY_F8; break;
case 0x12: specialkey = KEY_F9; break;
case 0x07: specialkey = KEY_F10; break;
case 0x09: specialkey = KEY_F11; break;
case 0x0b: specialkey = KEY_F12; break;
default: specialkey = 0; break;
}
return specialkey;
}
#endif
if (pKbd->CustomKeycodes) {
specialkey = pKbd->specialMap->map[scanCode];
}
return specialkey;
}
#define ModifierSet(k) ((modifiers & (k)) == (k))
static
Bool SpecialKey(InputInfoPtr pInfo, int key, Bool down, int modifiers)
{
KbdDevPtr pKbd = (KbdDevPtr) pInfo->private;
if(!pKbd->vtSwitchSupported)
return FALSE;
if ((ModifierSet(ControlMask | AltMask)) ||
(ModifierSet(ControlMask | AltLangMask))) {
if (VTSwitchEnabled && !xf86Info.vtSysreq && !xf86Info.dontVTSwitch) {
switch (key) {
case KEY_F1:
case KEY_F2:
case KEY_F3:
case KEY_F4:
case KEY_F5:
case KEY_F6:
case KEY_F7:
case KEY_F8:
case KEY_F9:
case KEY_F10:
if (down) {
ioctl(xf86Info.consoleFd, VT_ACTIVATE, key - KEY_F1 + 1);
return TRUE;
}
case KEY_F11:
case KEY_F12:
if (down) {
ioctl(xf86Info.consoleFd, VT_ACTIVATE, key - KEY_F11 + 11);
return TRUE;
}
}
}
}
#ifdef USE_VT_SYSREQ
if (VTSwitchEnabled && xf86Info.vtSysreq && !xf86Info.dontVTSwitch) {
switch (key) {
case KEY_F1:
case KEY_F2:
case KEY_F3:
case KEY_F4:
case KEY_F5:
case KEY_F6:
case KEY_F7:
case KEY_F8:
case KEY_F9:
case KEY_F10:
if (VTSysreqToggle && down) {
ioctl(xf86Info.consoleFd, VT_ACTIVATE, key - KEY_F1 + 1);
VTSysreqToggle = FALSE;
return TRUE;
}
break;
case KEY_F11:
case KEY_F12:
if (VTSysreqToggle && down) {
ioctl(xf86Info.consoleFd, VT_ACTIVATE, key - KEY_F11 + 11);
VTSysreqToggle = FALSE;
return TRUE;
}
break;
/* Ignore these keys -- ie don't let them cancel an alt-sysreq */
case KEY_Alt:
case KEY_AltLang:
break;
case KEY_SysReqest:
if ((ModifierSet(AltMask) || ModifierSet(AltLangMask)) && down)
VTSysreqToggle = TRUE;
break;
default:
/*
* We only land here when Alt-SysReq is followed by a
* non-switching key.
*/
if (VTSysreqToggle)
VTSysreqToggle = FALSE;
}
}
#endif /* USE_VT_SYSREQ */
return FALSE;
}
static void
stdReadInput(InputInfoPtr pInfo)
{
KbdDevPtr pKbd = (KbdDevPtr) pInfo->private;
unsigned char rBuf[64];
int nBytes, i;
if ((nBytes = read( pInfo->fd, (char *)rBuf, sizeof(rBuf))) > 0) {
for (i = 0; i < nBytes; i++)
pKbd->PostEvent(pInfo, rBuf[i] & 0x7f,
rBuf[i] & 0x80 ? FALSE : TRUE);
}
}
static Bool
OpenKeyboard(InputInfoPtr pInfo)
{
KbdDevPtr pKbd = (KbdDevPtr) pInfo->private;
int i;
KbdProtocolId prot = PROT_UNKNOWN_KBD;
char *s;
s = xf86SetStrOption(pInfo->options, "Protocol", NULL);
for (i = 0; protocols[i].name; i++) {
if (xf86NameCmp(s, protocols[i].name) == 0) {
prot = protocols[i].id;
break;
}
}
switch (prot) {
case PROT_STD:
pInfo->read_input = stdReadInput;
break;
default:
xf86Msg(X_ERROR,"\"%s\" is not a valid keyboard protocol name\n", s);
xfree(s);
return FALSE;
}
xf86Msg(X_CONFIG, "%s: Protocol: %s\n", pInfo->name, s);
xfree(s);
s = xf86SetStrOption(pInfo->options, "Device", NULL);
if (s == NULL) {
pInfo->fd = xf86Info.consoleFd;
pKbd->isConsole = TRUE;
} else {
pInfo->fd = open(s, O_RDONLY | O_NONBLOCK | O_EXCL);
if (pInfo->fd == -1) {
xf86Msg(X_ERROR, "%s: cannot open \"%s\"\n", pInfo->name, s);
xfree(s);
return FALSE;
}
pKbd->isConsole = FALSE;
xfree(s);
}
if (pKbd->isConsole)
pKbd->vtSwitchSupported = TRUE;
return TRUE;
}
_X_EXPORT Bool
xf86OSKbdPreInit(InputInfoPtr pInfo)
{
KbdDevPtr pKbd = pInfo->private;
pKbd->KbdInit = KbdInit;
pKbd->KbdOn = KbdOn;
pKbd->KbdOff = KbdOff;
pKbd->Bell = SoundBell;
pKbd->SetLeds = SetKbdLeds;
pKbd->GetLeds = GetKbdLeds;
pKbd->SetKbdRepeat = SetKbdRepeat;
pKbd->KbdGetMapping = KbdGetMapping;
pKbd->SpecialKey = SpecialKey;
pKbd->RemapScanCode = NULL;
pKbd->GetSpecialKey = GetSpecialKey;
pKbd->OpenKeyboard = OpenKeyboard;
pKbd->vtSwitchSupported = FALSE;
pKbd->private = xcalloc(sizeof(LnxKbdPrivRec), 1);
if (pKbd->private == NULL) {
xf86Msg(X_ERROR,"can't allocate keyboard OS private data\n");
return FALSE;
}
#if defined(__powerpc__)
{
FILE *f;
f = fopen("/proc/sys/dev/mac_hid/keyboard_sends_linux_keycodes","r");
if (f) {
if (fgetc(f) == '0')
pKbd->CustomKeycodes = TRUE;
fclose(f);
}
}
#endif
return TRUE;
}

308
hw/xfree86/parser/Keyboard.c
View File

@ -1,308 +0,0 @@
/*
*
* Copyright (c) 1997 Metro Link Incorporated
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
* OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
* Except as contained in this notice, the name of the Metro Link shall not be
* used in advertising or otherwise to promote the sale, use or other dealings
* in this Software without prior written authorization from Metro Link.
*
*/
/*
* Copyright (c) 1997-2003 by The XFree86 Project, Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*
* Except as contained in this notice, the name of the copyright holder(s)
* and author(s) shall not be used in advertising or otherwise to promote
* the sale, use or other dealings in this Software without prior written
* authorization from the copyright holder(s) and author(s).
*/
/* View/edit this file with tab stops set to 4 */
#ifdef HAVE_XORG_CONFIG_H
#include <xorg-config.h>
#endif
#include "xf86Parser.h"
#include "xf86tokens.h"
#include "Configint.h"
#include "ctype.h"
extern LexRec val;
static xf86ConfigSymTabRec KeyboardTab[] =
{
{ENDSECTION, "endsection"},
{KPROTOCOL, "protocol"},
{AUTOREPEAT, "autorepeat"},
{XLEDS, "xleds"},
{PANIX106, "panix106"},
{XKBKEYMAP, "xkbkeymap"},
{XKBCOMPAT, "xkbcompat"},
{XKBTYPES, "xkbtypes"},
{XKBKEYCODES, "xkbkeycodes"},
{XKBGEOMETRY, "xkbgeometry"},
{XKBSYMBOLS, "xkbsymbols"},
{XKBDISABLE, "xkbdisable"},
{XKBRULES, "xkbrules"},
{XKBMODEL, "xkbmodel"},
{XKBLAYOUT, "xkblayout"},
{XKBVARIANT, "xkbvariant"},
{XKBOPTIONS, "xkboptions"},
/* The next two have become ServerFlags options */
{VTINIT, "vtinit"},
{VTSYSREQ, "vtsysreq"},
/* Obsolete keywords */
{SERVERNUM, "servernumlock"},
{LEFTALT, "leftalt"},
{RIGHTALT, "rightalt"},
{RIGHTALT, "altgr"},
{SCROLLLOCK_TOK, "scrolllock"},
{RIGHTCTL, "rightctl"},
{-1, ""},
};
/* Obsolete */
static xf86ConfigSymTabRec KeyMapTab[] =
{
{CONF_KM_META, "meta"},
{CONF_KM_COMPOSE, "compose"},
{CONF_KM_MODESHIFT, "modeshift"},
{CONF_KM_MODELOCK, "modelock"},
{CONF_KM_SCROLLLOCK, "scrolllock"},
{CONF_KM_CONTROL, "control"},
{-1, ""},
};
#define CLEANUP xf86freeInputList
XF86ConfInputPtr
xf86parseKeyboardSection (void)
{
char *s, *s1, *s2;
int l;
int token, ntoken;
parsePrologue (XF86ConfInputPtr, XF86ConfInputRec)
while ((token = xf86getToken (KeyboardTab)) != ENDSECTION)
{
switch (token)
{
case COMMENT:
ptr->inp_comment = xf86addComment(ptr->inp_comment, val.str);
break;
case KPROTOCOL:
if (xf86getSubToken (&(ptr->inp_comment)) != STRING)
Error (QUOTE_MSG, "Protocol");
ptr->inp_option_lst = xf86addNewOption(ptr->inp_option_lst,
xf86configStrdup("Protocol"),
val.str);
break;
case AUTOREPEAT:
if (xf86getSubToken (&(ptr->inp_comment)) != NUMBER)
Error (AUTOREPEAT_MSG, NULL);
s1 = xf86uLongToString(val.num);
if (xf86getSubToken (&(ptr->inp_comment)) != NUMBER) {
xf86conffree(s1);
Error (AUTOREPEAT_MSG, NULL);
}
s2 = xf86uLongToString(val.num);
l = strlen(s1) + 1 + strlen(s2) + 1;
s = xf86confmalloc(l);
sprintf(s, "%s %s", s1, s2);
xf86conffree(s1);
xf86conffree(s2);
ptr->inp_option_lst = xf86addNewOption(ptr->inp_option_lst,
xf86configStrdup("AutoRepeat"), s);
break;
case XLEDS:
if (xf86getSubToken (&(ptr->inp_comment)) != NUMBER)
Error (XLEDS_MSG, NULL);
s = xf86uLongToString(val.num);
l = strlen(s) + 1;
while ((token = xf86getSubToken (&(ptr->inp_comment))) == NUMBER)
{
s1 = xf86uLongToString(val.num);
l += (1 + strlen(s1));
s = xf86confrealloc(s, l);
strcat(s, " ");
strcat(s, s1);
xf86conffree(s1);
}
xf86unGetToken (token);
xf86conffree(s);
break;
case SERVERNUM:
xf86parseWarning(OBSOLETE_MSG, xf86tokenString());
break;
case LEFTALT:
case RIGHTALT:
case SCROLLLOCK_TOK:
case RIGHTCTL:
xf86parseWarning(OBSOLETE_MSG, xf86tokenString());
break;
ntoken = xf86getToken (KeyMapTab);
switch (ntoken)
{
case EOF_TOKEN:
xf86parseError (UNEXPECTED_EOF_MSG);
CLEANUP (ptr);
return (NULL);
break;
default:
Error (INVALID_KEYWORD_MSG, xf86tokenString ());
break;
}
break;
case VTINIT:
if (xf86getSubToken (&(ptr->inp_comment)) != STRING)
Error (QUOTE_MSG, "VTInit");
xf86parseWarning(MOVED_TO_FLAGS_MSG, "VTInit");
break;
case VTSYSREQ:
xf86parseWarning(MOVED_TO_FLAGS_MSG, "VTSysReq");
break;
case XKBDISABLE:
ptr->inp_option_lst = xf86addNewOption(ptr->inp_option_lst,
xf86configStrdup("XkbDisable"),
NULL);
break;
case XKBKEYMAP:
if (xf86getSubToken (&(ptr->inp_comment)) != STRING)
Error (QUOTE_MSG, "XKBKeymap");
ptr->inp_option_lst = xf86addNewOption(ptr->inp_option_lst,
xf86configStrdup("XkbKeymap"),
val.str);
break;
case XKBCOMPAT:
if (xf86getSubToken (&(ptr->inp_comment)) != STRING)
Error (QUOTE_MSG, "XKBCompat");
ptr->inp_option_lst = xf86addNewOption(ptr->inp_option_lst,
xf86configStrdup("XkbCompat"),
val.str);
break;
case XKBTYPES:
if (xf86getSubToken (&(ptr->inp_comment)) != STRING)
Error (QUOTE_MSG, "XKBTypes");
ptr->inp_option_lst = xf86addNewOption(ptr->inp_option_lst,
xf86configStrdup("XkbTypes"),
val.str);
break;
case XKBKEYCODES:
if (xf86getSubToken (&(ptr->inp_comment)) != STRING)
Error (QUOTE_MSG, "XKBKeycodes");
ptr->inp_option_lst = xf86addNewOption(ptr->inp_option_lst,
xf86configStrdup("XkbKeycodes"),
val.str);
break;
case XKBGEOMETRY:
if (xf86getSubToken (&(ptr->inp_comment)) != STRING)
Error (QUOTE_MSG, "XKBGeometry");
ptr->inp_option_lst = xf86addNewOption(ptr->inp_option_lst,
xf86configStrdup("XkbGeometry"),
val.str);
break;
case XKBSYMBOLS:
if (xf86getSubToken (&(ptr->inp_comment)) != STRING)
Error (QUOTE_MSG, "XKBSymbols");
ptr->inp_option_lst = xf86addNewOption(ptr->inp_option_lst,
xf86configStrdup("XkbSymbols"),
val.str);
break;
case XKBRULES:
if (xf86getSubToken (&(ptr->inp_comment)) != STRING)
Error (QUOTE_MSG, "XKBRules");
ptr->inp_option_lst = xf86addNewOption(ptr->inp_option_lst,
xf86configStrdup("XkbRules"),
val.str);
break;
case XKBMODEL:
if (xf86getSubToken (&(ptr->inp_comment)) != STRING)
Error (QUOTE_MSG, "XKBModel");
ptr->inp_option_lst = xf86addNewOption(ptr->inp_option_lst,
xf86configStrdup("XkbModel"),
val.str);
break;
case XKBLAYOUT:
if (xf86getSubToken (&(ptr->inp_comment)) != STRING)
Error (QUOTE_MSG, "XKBLayout");
ptr->inp_option_lst = xf86addNewOption(ptr->inp_option_lst,
xf86configStrdup("XkbLayout"),
val.str);
break;
case XKBVARIANT:
if (xf86getSubToken (&(ptr->inp_comment)) != STRING)
Error (QUOTE_MSG, "XKBVariant");
ptr->inp_option_lst = xf86addNewOption(ptr->inp_option_lst,
xf86configStrdup("XkbVariant"),
val.str);
break;
case XKBOPTIONS:
if (xf86getSubToken (&(ptr->inp_comment)) != STRING)
Error (QUOTE_MSG, "XKBOptions");
ptr->inp_option_lst = xf86addNewOption(ptr->inp_option_lst,
xf86configStrdup("XkbOptions"),
val.str);
break;
case PANIX106:
ptr->inp_option_lst = xf86addNewOption(ptr->inp_option_lst,
xf86configStrdup("Panix106"), NULL);
break;
case EOF_TOKEN:
Error (UNEXPECTED_EOF_MSG, NULL);
break;
default:
Error (INVALID_KEYWORD_MSG, xf86tokenString ());
break;
}
}
ptr->inp_identifier = xf86configStrdup(CONF_IMPLICIT_KEYBOARD);
ptr->inp_driver = xf86configStrdup("keyboard");
ptr->inp_option_lst = xf86addNewOption(ptr->inp_option_lst,
xf86configStrdup("CoreKeyboard"), NULL);
#ifdef DEBUG
printf ("Keyboard section parsed\n");
#endif
return ptr;
}