Magellan Linux

  • Back to homepage
    • /[pkg-src]/trunk/xorg-old/patches-6.8.2-r10/9001_all_4.3.0-lnx-evdev-keyboard-v2.patch

    Contents of /trunk/xorg-old/patches-6.8.2-r10/9001_all_4.3.0-lnx-evdev-keyboard-v2.patch

    Parent Directory Parent Directory | Revision Log Revision Log

    Revision 167 - (show annotations) (download)
    Tue May 8 20:58:51 2007 UTC (17 years ago) by niro
    File size: 10093 byte(s) 
    -import
    1 Version 2 by Alan Swanson <swanson@ukfsn.org>
    2 Restores case insensitivity of Option "Protocol" "Standard"
    3 http://bugs.gentoo.org/show_bug.cgi?id=63568
    4 -Donnie Berkholz <spyderous@gentoo.org>
    5 11 Oct. 2004
    6
    7 diff -ur build-tree/xc/programs/Xserver/hw/xfree86/os-support/linux/lnx_kbd.c xc/programs/Xserver/hw/xfree86/os-support/linux/lnx_kbd.c
    8 --- build-tree/xc/programs/Xserver/hw/xfree86/os-support/linux/lnx_kbd.c 2003-03-26 19:53:47.000000000 -0500
    9 +++ xc/programs/Xserver/hw/xfree86/os-support/linux/lnx_kbd.c 2003-03-15 08:46:16.000000000 -0500
    10 @@ -22,6 +22,7 @@
    11 #include "xf86OSKbd.h"
    12 #include "atKeynames.h"
    13 #include "lnx_kbd.h"
    14 +#include "lnx_evdev.h"
    15
    16 #define KBC_TIMEOUT 250 /* Timeout in ms for sending to keyboard controller */
    17
    18 @@ -481,8 +482,8 @@
    19 return TRUE;
    20 }
    21
    22 -Bool
    23 -xf86OSKbdPreInit(InputInfoPtr pInfo)
    24 +static Bool
    25 +stdKbdPreInit(InputInfoPtr pInfo, char *protocol)
    26 {
    27 KbdDevPtr pKbd = pInfo->private;
    28
    29 @@ -532,3 +533,377 @@
    30 #endif
    31 return TRUE;
    32 }
    33 +
    34 +typedef struct _evdevKbdRec {
    35 + int packetSize;
    36 + char *buffer;
    37 + evdevDriver evdev;
    38 +} evdevKbdRec, *evdevKbdPtr;
    39 +
    40 +static void
    41 +evdevKbdReadInput(InputInfoPtr pInfo)
    42 +{
    43 + KbdDevPtr pKbd;
    44 + evdevKbdPtr evdevKbd;
    45 + struct input_event *ev;
    46 + int n;
    47 + int code;
    48 +
    49 + pKbd = (KbdDevPtr) pInfo->private;
    50 + evdevKbd = pKbd->private;
    51 + ev = (struct input_event *) evdevKbd->buffer;
    52 +
    53 + if (pInfo->fd == -1)
    54 + return;
    55 +
    56 + do {
    57 + n = read(pInfo->fd, ev, sizeof(struct input_event));
    58 + if (n == -1) {
    59 + xf86Msg(X_ERROR, "%s: Error in reading! (%s) Disabiling.\n",
    60 + pInfo->name, strerror(errno));
    61 + RemoveEnabledDevice(pInfo->fd);
    62 + close (pInfo->fd);
    63 + pInfo->dev->public.on = FALSE;
    64 + pInfo->fd = -1;
    65 + return;
    66 + }
    67 + if (n != sizeof(struct input_event)) {
    68 + xf86Msg(X_WARNING, "%s: incomplete packet, size %d\n", pInfo->name, n);
    69 + return;
    70 + }
    71 +
    72 + switch (ev->type) {
    73 + case EV_KEY:
    74 + if ((ev->code <= EV_KEY_RESERVED)||(ev->code >= EV_KEY_UNKNOWN))
    75 + break;
    76 + switch (ev->code) {
    77 + case EV_KEY_103RD:
    78 + case EV_KEY_102ND:
    79 + case EV_KEY_LINEFEED:
    80 + case EV_KEY_MACRO:
    81 + case EV_KEY_MUTE:
    82 + case EV_KEY_VOLUMEDOWN:
    83 + case EV_KEY_VOLUMEUP:
    84 + case EV_KEY_POWER:
    85 + case EV_KEY_KPPLUSMINUS:
    86 + case EV_KEY_F18:
    87 + case EV_KEY_F19:
    88 + case EV_KEY_F20:
    89 + case EV_KEY_F21:
    90 + case EV_KEY_F22:
    91 + case EV_KEY_F23:
    92 + case EV_KEY_F24:
    93 + case EV_KEY_KPCOMMA:
    94 + case EV_KEY_COMPOSE:
    95 + code = KEY_UNKNOWN;
    96 + break;
    97 + case EV_KEY_F13:
    98 + code = KEY_F13;
    99 + break;
    100 + case EV_KEY_F14:
    101 + code = KEY_F14;
    102 + break;
    103 + case EV_KEY_F15:
    104 + code = KEY_F15;
    105 + break;
    106 + case EV_KEY_F16:
    107 + code = KEY_F16;
    108 + break;
    109 + case EV_KEY_F17:
    110 + code = KEY_F17;
    111 + break;
    112 + case EV_KEY_KPENTER:
    113 + code = KEY_KP_Enter;
    114 + break;
    115 + case EV_KEY_RIGHTCTRL:
    116 + code = KEY_RCtrl;
    117 + break;
    118 + case EV_KEY_KPSLASH:
    119 + code = KEY_KP_Divide;
    120 + break;
    121 + case EV_KEY_SYSRQ:
    122 + code = KEY_SysReqest;
    123 + break;
    124 + case EV_KEY_RIGHTALT:
    125 + code = KEY_AltLang;
    126 + break;
    127 + case EV_KEY_HOME:
    128 + code = KEY_Home;
    129 + break;
    130 + case EV_KEY_UP:
    131 + code = KEY_Up;
    132 + break;
    133 + case EV_KEY_PAGEUP:
    134 + code = KEY_PgUp;
    135 + break;
    136 + case EV_KEY_LEFT:
    137 + code = KEY_Left;
    138 + break;
    139 + case EV_KEY_RIGHT:
    140 + code = KEY_Right;
    141 + break;
    142 + case EV_KEY_END:
    143 + code = KEY_End;
    144 + break;
    145 + case EV_KEY_DOWN:
    146 + code = KEY_Down;
    147 + break;
    148 + case EV_KEY_PAGEDOWN:
    149 + code = KEY_PgDown;
    150 + break;
    151 + case EV_KEY_INSERT:
    152 + code = KEY_Insert;
    153 + break;
    154 + case EV_KEY_DELETE:
    155 + code = KEY_Delete;
    156 + break;
    157 + case EV_KEY_KPEQUAL:
    158 + code = KEY_KP_Equal;
    159 + break;
    160 + case EV_KEY_PAUSE:
    161 + code = KEY_Pause;
    162 + break;
    163 + case EV_KEY_LEFTMETA:
    164 + code = KEY_LMeta;
    165 + break;
    166 + case EV_KEY_RIGHTMETA:
    167 + code = KEY_RMeta;
    168 + break;
    169 + default:
    170 + code = ev->code;
    171 + break;
    172 + }
    173 + if (code >= 127)
    174 + code = KEY_UNKNOWN;
    175 +
    176 + if (ev->value)
    177 + pKbd->PostEvent(pInfo, code, TRUE);
    178 + else
    179 + pKbd->PostEvent(pInfo, code, FALSE);
    180 + break;
    181 + }
    182 + } while (xf86WaitForInput(pInfo->fd, 0));
    183 +
    184 + return;
    185 +}
    186 +
    187 +static int
    188 +evdevKbdInit(InputInfoPtr pInfo, int what)
    189 +{
    190 + KbdDevPtr pKbd = (KbdDevPtr) pInfo->private;
    191 + evdevKbdPtr evdevKbd = (evdevKbdPtr) pKbd->private;
    192 +
    193 + evdevKbd->evdev.name = xf86SetStrOption(pInfo->options,"Dev Name",NULL);
    194 + evdevKbd->evdev.phys = xf86SetStrOption(pInfo->options,"Dev Phys",NULL);
    195 + evdevKbd->evdev.cb_data = pInfo->dev;
    196 + evdevKbd->evdev.callback = pInfo->device_control;
    197 + if (!evdevNewDriver (&evdevKbd->evdev)) {
    198 + xf86Msg(X_ERROR, "%s: cannot register with evdev brain\n", pInfo->name);
    199 + return BadRequest;
    200 + }
    201 + if ((pInfo->fd = evdevGetFDForDriver (&evdevKbd->evdev)) == -1) {
    202 + xf86Msg(X_ERROR, "%s: cannot open input device\n", pInfo->name);
    203 + return BadRequest;
    204 + }
    205 +
    206 + close(pInfo->fd);
    207 + pInfo->fd = -1;
    208 +
    209 + return Success;
    210 +}
    211 +
    212 +static int
    213 +evdevKbdOn(InputInfoPtr pInfo, int what)
    214 +{
    215 + KbdDevPtr pKbd = (KbdDevPtr) pInfo->private;
    216 + evdevKbdPtr evdevKbd = (evdevKbdPtr) pKbd->private;
    217 + unsigned long mask;
    218 +
    219 + if ((pInfo->fd = evdevGetFDForDriver (&evdevKbd->evdev)) == -1) {
    220 + xf86Msg(X_ERROR, "%s: cannot open input device (name: '%s', phys: '%s')\n", pInfo->name, evdevKbd->evdev.name, evdevKbd->evdev.phys);
    221 + return BadRequest;
    222 + }
    223 + /*
    224 + * Grab the keyboard for ourselves.
    225 + */
    226 + if (ioctl(pInfo->fd, EVIOCGMASK, &mask) < 0) {
    227 + xf86Msg(X_INFO, "%s: unable to use input device masking '%s', trying grabbing.\n", pInfo->name, strerror(errno));
    228 + if (ioctl(pInfo->fd, EVIOCGRAB, 1) < 0) {
    229 + xf86Msg(X_ERROR, "%s: unable to grab device '%s', you may have problems.\n", pInfo->name, strerror(errno));
    230 + }
    231 + return Success;
    232 + }
    233 +
    234 + mask |= BIT(2);
    235 + ioctl(pInfo->fd, EVIOCSMASK, mask);
    236 +
    237 + ioctl(pInfo->fd, EVIOCGDMASK, &mask);
    238 + mask &= ~BIT(0);
    239 + mask |= BIT(2);
    240 + ioctl(pInfo->fd, EVIOCSDMASK, mask);
    241 + xf86Msg(X_INFO, "%s: Using input device masking.\n", pInfo->name);
    242 +
    243 + return Success;
    244 +}
    245 +
    246 +static int
    247 +evdevKbdOff(InputInfoPtr pInfo, int what)
    248 +{
    249 + if (pInfo->fd != -1) {
    250 + unsigned long mask;
    251 +
    252 + if (ioctl(pInfo->fd, EVIOCGDMASK, &mask) >= 0) {
    253 + mask |= BIT(0);
    254 + ioctl(pInfo->fd, EVIOCSDMASK, mask);
    255 + }
    256 +
    257 + close (pInfo->fd);
    258 + pInfo->fd = -1;
    259 + }
    260 + return Success;
    261 +}
    262 +
    263 +static void
    264 +evdevSoundBell(InputInfoPtr pInfo, int loudness, int pitch, int duration)
    265 +{
    266 +}
    267 +
    268 +static void
    269 +evdevSetKbdLeds(InputInfoPtr pInfo, int leds)
    270 +{
    271 + struct input_event event;
    272 +
    273 + memset(&event, 0, sizeof(event));
    274 + event.type = EV_LED;
    275 + event.code = EV_LED_CAPSL;
    276 + event.value = (leds & XLED1) ? 1 : 0;
    277 + write(pInfo->fd, (char *) &event, sizeof(event));
    278 +
    279 + event.type = EV_LED;
    280 + event.code = EV_LED_NUML;
    281 + event.value = (leds & XLED2) ? 1 : 0;
    282 + write(pInfo->fd, (char *) &event, sizeof(event));
    283 +
    284 + event.type = EV_LED;
    285 + event.code = EV_LED_SCROLLL;
    286 + event.value = (leds & XLED3) ? 1 : 0;
    287 + write(pInfo->fd, (char *) &event, sizeof(event));
    288 +
    289 + event.type = EV_LED;
    290 + event.code = EV_LED_COMPOSE;
    291 + event.value = (leds & XLED4) ? 1 : 0;
    292 + write(pInfo->fd, (char *) &event, sizeof(event));
    293 +}
    294 +
    295 +static int
    296 +evdevGetKbdLeds(InputInfoPtr pInfo)
    297 +{
    298 + unsigned long evleds[NBITS(EV_LED_MAX)];
    299 + int leds = 0;
    300 +
    301 + ioctl(pInfo->fd, EVIOCGLED(sizeof(evleds)), &evleds);
    302 + if (test_bit(EV_LED_CAPSL, evleds))
    303 + leds |= XLED1;
    304 +
    305 + if (test_bit(EV_LED_NUML, evleds))
    306 + leds |= XLED2;
    307 +
    308 + if (test_bit(EV_LED_SCROLLL, evleds))
    309 + leds |= XLED3;
    310 +
    311 + if (test_bit(EV_LED_COMPOSE, evleds))
    312 + leds |= XLED4;
    313 +
    314 + return leds;
    315 +}
    316 +
    317 +static void
    318 +evdevSetKbdRepeat(InputInfoPtr pInfo, char rad)
    319 +{
    320 + KbdDevPtr pKbd = (KbdDevPtr) pInfo->private;
    321 + int rep_info[2];
    322 +
    323 + rep_info[0] = pKbd->delay;
    324 + rep_info[1] = pKbd->rate * 10;
    325 + ioctl(pInfo->fd, EVIOCSREP, rep_info);
    326 +}
    327 +
    328 +static int
    329 +evdevGetSpecialKey(InputInfoPtr pInfo, int scanCode)
    330 +{
    331 + return scanCode;
    332 +}
    333 +
    334 +static Bool
    335 +evdevOpenKeyboard(InputInfoPtr pInfo)
    336 +{
    337 + return TRUE;
    338 +}
    339 +
    340 +static Bool
    341 +evdevKbdPreInit(InputInfoPtr pInfo, char *protocol)
    342 +{
    343 + KbdDevPtr pKbd = pInfo->private;
    344 + evdevKbdPtr evdevKbd;
    345 + xf86Msg(X_CONFIG, "%s: Protocol: %s\n", pInfo->name, protocol);
    346 +
    347 + pKbd->private = evdevKbd = xcalloc(sizeof(evdevKbdRec), 1);
    348 +
    349 + xf86Msg(X_ERROR, "%s: pInfo->dev: %p\n", pInfo->name, pInfo->dev);
    350 +
    351 + if (pKbd->private == NULL) {
    352 + xf86Msg(X_ERROR, "%s: cannot allocate buffer\n", pInfo->name);
    353 + return FALSE;
    354 + }
    355 +
    356 + evdevKbd->buffer = xcalloc(sizeof(struct input_event),1);
    357 +
    358 + if (evdevKbd->buffer == NULL) {
    359 + xf86Msg(X_ERROR, "%s: cannot allocate buffer\n", pInfo->name);
    360 + xfree(evdevKbd);
    361 + return FALSE;
    362 + }
    363 +
    364 + if (!evdevStart (pInfo->drv)) {
    365 + xf86Msg(X_ERROR, "%s: cannot start evdev brain\n", pInfo->name);
    366 + xfree(evdevKbd);
    367 + xfree(evdevKbd->buffer);
    368 + return FALSE;
    369 + }
    370 +
    371 + pKbd->KbdInit = evdevKbdInit;
    372 + pKbd->KbdOn = evdevKbdOn;
    373 + pKbd->KbdOff = evdevKbdOff;
    374 + pKbd->Bell = evdevSoundBell;
    375 + pKbd->SetLeds = evdevSetKbdLeds;
    376 + pKbd->GetLeds = evdevGetKbdLeds;
    377 + pKbd->SetKbdRepeat = evdevSetKbdRepeat;
    378 + pKbd->KbdGetMapping = KbdGetMapping;
    379 + pKbd->SpecialKey = SpecialKey;
    380 +
    381 + pKbd->RemapScanCode = NULL;
    382 + pKbd->GetSpecialKey = evdevGetSpecialKey;
    383 +
    384 + pKbd->OpenKeyboard = evdevOpenKeyboard;
    385 + pKbd->vtSwitchSupported = FALSE;
    386 + pInfo->read_input = evdevKbdReadInput;
    387 +
    388 + return TRUE;
    389 +}
    390 +
    391 +Bool
    392 +xf86OSKbdPreInit(InputInfoPtr pInfo)
    393 +{
    394 + char *protocol;
    395 + Bool ret;
    396 +
    397 + protocol = xf86SetStrOption(pInfo->options, "Protocol", NULL);
    398 +
    399 + if (xf86NameCmp(protocol, "evdev") == 0)
    400 + ret = evdevKbdPreInit(pInfo, protocol);
    401 + else
    402 + ret = stdKbdPreInit(pInfo, protocol);
    403 +
    404 + xfree(protocol);
    405 + return ret;
    406 +}