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

    Annotation 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 - (hide annotations) (download)
    Tue May 8 20:58:51 2007 UTC (17 years, 1 month ago) by niro
    File size: 10093 byte(s) 
    -import
    1 niro 167 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     +}