Attachment #21551 for bug #29953

View | Details | Raw Unified | Return to bug 29953 | Differences between
Collapse All | Expand All




#include "xf86OSKbd.h"
#include "atKeynames.h"
#include "lnx_kbd.h"
#include "lnx_evdev.h"

#define KBC_TIMEOUT 250        /* Timeout in ms for sending to keyboard controller */


    return TRUE;
}

static Bool
stdKbdPreInit(InputInfoPtr pInfo, char *protocol)
{
    KbdDevPtr pKbd = pInfo->private;


#endif
    return TRUE;
}

typedef struct _evdevKbdRec {
    int packetSize;
    char *buffer;
    evdevDriver evdev;
} evdevKbdRec, *evdevKbdPtr;

static void
evdevKbdReadInput(InputInfoPtr pInfo)
{
    KbdDevPtr pKbd;
    evdevKbdPtr evdevKbd;
    struct input_event *ev;
    int n;
    int code;

    pKbd = (KbdDevPtr) pInfo->private;
    evdevKbd = pKbd->private;
    ev = (struct input_event *) evdevKbd->buffer;

    if (pInfo->fd == -1)
	return;

    do {
	n = read(pInfo->fd, ev, sizeof(struct input_event));
	if (n == -1) {
	    xf86Msg(X_ERROR, "%s: Error in reading! (%s) Disabiling.\n",
		    pInfo->name, strerror(errno));
	    RemoveEnabledDevice(pInfo->fd);
	    close (pInfo->fd);
	    pInfo->dev->public.on = FALSE;
	    pInfo->fd = -1;
	    return;
	}
	if (n != sizeof(struct input_event)) {
	    xf86Msg(X_WARNING, "%s: incomplete packet, size %d\n", pInfo->name, n);
	    return;
	}

	switch (ev->type) {
	    case EV_KEY:
		if ((ev->code <= EV_KEY_RESERVED)||(ev->code >= EV_KEY_UNKNOWN))
		    break;
		switch (ev->code) {
		    case EV_KEY_103RD:
		    case EV_KEY_102ND:
		    case EV_KEY_LINEFEED:
		    case EV_KEY_MACRO:
		    case EV_KEY_MUTE:
		    case EV_KEY_VOLUMEDOWN:
		    case EV_KEY_VOLUMEUP:
		    case EV_KEY_POWER:
		    case EV_KEY_KPPLUSMINUS:
		    case EV_KEY_F18:
		    case EV_KEY_F19:
		    case EV_KEY_F20:
		    case EV_KEY_F21:
		    case EV_KEY_F22:
		    case EV_KEY_F23:
		    case EV_KEY_F24:
		    case EV_KEY_KPCOMMA:
		    case EV_KEY_COMPOSE:
			code = KEY_UNKNOWN;
			break;
		    case EV_KEY_F13:
			code = KEY_F13;
			break;
		    case EV_KEY_F14:
			code = KEY_F14;
			break;
		    case EV_KEY_F15:
			code = KEY_F15;
			break;
		    case EV_KEY_F16:
			code = KEY_F16;
			break;
		    case EV_KEY_F17:
			code = KEY_F17;
			break;
		    case EV_KEY_KPENTER:
			code = KEY_KP_Enter;
			break;
		    case EV_KEY_RIGHTCTRL:
			code = KEY_RCtrl;
			break;
		    case EV_KEY_KPSLASH:
			code = KEY_KP_Divide;
			break;
		    case EV_KEY_SYSRQ:
			code = KEY_SysReqest;
			break;
		    case EV_KEY_RIGHTALT:
			code = KEY_AltLang;
			break;
		    case EV_KEY_HOME:
			code = KEY_Home;
			break;
		    case EV_KEY_UP:
			code = KEY_Up;
			break;
		    case EV_KEY_PAGEUP:
			code = KEY_PgUp;
			break;
		    case EV_KEY_LEFT:
			code = KEY_Left;
			break;
		    case EV_KEY_RIGHT:
			code = KEY_Right;
			break;
		    case EV_KEY_END:
			code = KEY_End;
			break;
		    case EV_KEY_DOWN:
			code = KEY_Down;
			break;
		    case EV_KEY_PAGEDOWN:
			code = KEY_PgDown;
			break;
		    case EV_KEY_INSERT:
			code = KEY_Insert;
			break;
		    case EV_KEY_DELETE:
			code = KEY_Delete;
			break;
		    case EV_KEY_KPEQUAL:
			code = KEY_KP_Equal;
			break;
		    case EV_KEY_PAUSE:
			code = KEY_Pause;
			break;
		    case EV_KEY_LEFTMETA:
			code = KEY_LMeta;
			break;
		    case EV_KEY_RIGHTMETA:
			code = KEY_RMeta;
			break;
		    default:
			code = ev->code;
			break;
		}
		if (code >= 127)
		    code = KEY_UNKNOWN;

		if (ev->value)
		    pKbd->PostEvent(pInfo, code, TRUE);
		else
		    pKbd->PostEvent(pInfo, code, FALSE);
		break;
	}
    } while (xf86WaitForInput(pInfo->fd, 0));

    return;
}

static int
evdevKbdInit(InputInfoPtr pInfo, int what)
{
    KbdDevPtr pKbd = (KbdDevPtr) pInfo->private;
    evdevKbdPtr evdevKbd = (evdevKbdPtr) pKbd->private;

    evdevKbd->evdev.name = xf86SetStrOption(pInfo->options,"Dev Name",NULL);
    evdevKbd->evdev.phys = xf86SetStrOption(pInfo->options,"Dev Phys",NULL);
    evdevKbd->evdev.cb_data = pInfo->dev;
    evdevKbd->evdev.callback = pInfo->device_control;
    if (!evdevNewDriver (&evdevKbd->evdev)) {
	xf86Msg(X_ERROR, "%s: cannot register with evdev brain\n", pInfo->name);
	return BadRequest;
    }
    if ((pInfo->fd = evdevGetFDForDriver (&evdevKbd->evdev)) == -1) {
	xf86Msg(X_ERROR, "%s: cannot open input device\n", pInfo->name);
	return BadRequest;
    }

    close(pInfo->fd);
    pInfo->fd = -1;

    return Success;
}

static int
evdevKbdOn(InputInfoPtr pInfo, int what)
{
    KbdDevPtr pKbd = (KbdDevPtr) pInfo->private;
    evdevKbdPtr evdevKbd = (evdevKbdPtr) pKbd->private;
    unsigned long mask;

    if ((pInfo->fd = evdevGetFDForDriver (&evdevKbd->evdev)) == -1) {
	xf86Msg(X_ERROR, "%s: cannot open input device (name: '%s', phys: '%s')\n", pInfo->name, evdevKbd->evdev.name, evdevKbd->evdev.phys);
	return BadRequest;
    }
    /*
     * Grab the keyboard for ourselves.
     */
    if (ioctl(pInfo->fd, EVIOCGMASK, &mask) < 0) {
	xf86Msg(X_INFO, "%s: unable to use input device masking '%s', trying grabbing.\n", pInfo->name, strerror(errno));
	if (ioctl(pInfo->fd, EVIOCGRAB, 1) < 0) {
	    xf86Msg(X_ERROR, "%s: unable to grab device '%s', you may have problems.\n", pInfo->name, strerror(errno));
	}
	return Success;
    }

    mask |= BIT(2);
    ioctl(pInfo->fd, EVIOCSMASK, mask);

    ioctl(pInfo->fd, EVIOCGDMASK, &mask);
    mask &= ~BIT(0);
    mask |= BIT(2);
    ioctl(pInfo->fd, EVIOCSDMASK, mask);
    xf86Msg(X_INFO, "%s: Using input device masking.\n", pInfo->name);

    return Success;
}

static int
evdevKbdOff(InputInfoPtr pInfo, int what)
{
    if (pInfo->fd != -1) {
	unsigned long mask;

	if (ioctl(pInfo->fd, EVIOCGDMASK, &mask) >= 0) {
	    mask |= BIT(0);
	    ioctl(pInfo->fd, EVIOCSDMASK, mask);
	}

	close (pInfo->fd);
	pInfo->fd = -1;
    }
    return Success;
}

static void
evdevSoundBell(InputInfoPtr pInfo, int loudness, int pitch, int duration)
{
}

static void
evdevSetKbdLeds(InputInfoPtr pInfo, int leds)
{
    struct input_event event;

    memset(&event, 0, sizeof(event));
    event.type = EV_LED;
    event.code = EV_LED_CAPSL;
    event.value = (leds & XLED1) ? 1 : 0;
    write(pInfo->fd, (char *) &event, sizeof(event));

    event.type = EV_LED;
    event.code = EV_LED_NUML;
    event.value = (leds & XLED2) ? 1 : 0;
    write(pInfo->fd, (char *) &event, sizeof(event));

    event.type = EV_LED;
    event.code = EV_LED_SCROLLL;
    event.value = (leds & XLED3) ? 1 : 0;
    write(pInfo->fd, (char *) &event, sizeof(event));

    event.type = EV_LED;
    event.code = EV_LED_COMPOSE;
    event.value = (leds & XLED4) ? 1 : 0;
    write(pInfo->fd, (char *) &event, sizeof(event));
}

static int
evdevGetKbdLeds(InputInfoPtr pInfo)
{
    unsigned long evleds[NBITS(EV_LED_MAX)];
    int leds = 0;

    ioctl(pInfo->fd, EVIOCGLED(sizeof(evleds)), &evleds);
    if (test_bit(EV_LED_CAPSL, evleds))
	leds |= XLED1;

    if (test_bit(EV_LED_NUML, evleds))
	leds |= XLED2;

    if (test_bit(EV_LED_SCROLLL, evleds))
	leds |= XLED3;

    if (test_bit(EV_LED_COMPOSE, evleds))
	leds |= XLED4;

    return leds;
}

static void
evdevSetKbdRepeat(InputInfoPtr pInfo, char rad)
{
    KbdDevPtr pKbd = (KbdDevPtr) pInfo->private;
    int	rep_info[2];
    
    rep_info[0] = pKbd->delay;
    rep_info[1] = pKbd->rate * 10;
    ioctl(pInfo->fd, EVIOCSREP, rep_info);
}

static int
evdevGetSpecialKey(InputInfoPtr pInfo, int scanCode)
{
    return scanCode;
}

static Bool
evdevOpenKeyboard(InputInfoPtr pInfo)
{
    return TRUE;
}

static Bool
evdevKbdPreInit(InputInfoPtr pInfo, char *protocol)
{
    KbdDevPtr pKbd = pInfo->private;
    evdevKbdPtr evdevKbd;
    xf86Msg(X_CONFIG, "%s: Protocol: %s\n", pInfo->name, protocol);

    pKbd->private = evdevKbd = xcalloc(sizeof(evdevKbdRec), 1);

    xf86Msg(X_ERROR, "%s: pInfo->dev: %p\n", pInfo->name, pInfo->dev);

    if (pKbd->private == NULL) {
	xf86Msg(X_ERROR, "%s: cannot allocate buffer\n", pInfo->name);
	return FALSE;
    }

    evdevKbd->buffer = xcalloc(sizeof(struct input_event),1);

    if (evdevKbd->buffer == NULL) {
	xf86Msg(X_ERROR, "%s: cannot allocate buffer\n", pInfo->name);
	xfree(evdevKbd);
	return FALSE;
    }

    if (!evdevStart (pInfo->drv)) {
	xf86Msg(X_ERROR, "%s: cannot start evdev brain\n", pInfo->name);
	xfree(evdevKbd);
	xfree(evdevKbd->buffer);
	return FALSE;
    }

    pKbd->KbdInit       = evdevKbdInit;
    pKbd->KbdOn         = evdevKbdOn;
    pKbd->KbdOff        = evdevKbdOff;
    pKbd->Bell          = evdevSoundBell;
    pKbd->SetLeds       = evdevSetKbdLeds;
    pKbd->GetLeds       = evdevGetKbdLeds;
    pKbd->SetKbdRepeat  = evdevSetKbdRepeat;
    pKbd->KbdGetMapping = KbdGetMapping;
    pKbd->SpecialKey    = SpecialKey;

    pKbd->RemapScanCode = NULL;
    pKbd->GetSpecialKey = evdevGetSpecialKey;

    pKbd->OpenKeyboard = evdevOpenKeyboard;
    pKbd->vtSwitchSupported = FALSE;
    pInfo->read_input = evdevKbdReadInput;

    return TRUE;
}

Bool
xf86OSKbdPreInit(InputInfoPtr pInfo)
{
    char *protocol;
    Bool ret;

    protocol = xf86SetStrOption(pInfo->options, "Protocol", NULL);

    if (!protocol)
	ret = FALSE;
    else if (!strcmp(protocol, "standard"))
	ret = stdKbdPreInit(pInfo, protocol);
    else if (!strcmp(protocol, "evdev"))
	ret = evdevKbdPreInit(pInfo, protocol);
    else
	ret = FALSE;

    xfree(protocol);
    return ret;
}

Return to bug 29953

Lines 22-27 Link Here

(-)build-tree/xc/programs/Xserver/hw/xfree86/os-support/linux/lnx_kbd.c (-2 / +381 lines)
22	#include "xf86OSKbd.h"	22	#include "xf86OSKbd.h"
23	#include "atKeynames.h"	23	#include "atKeynames.h"
24	#include "lnx_kbd.h"	24	#include "lnx_kbd.h"
		25	#include "lnx_evdev.h"
25		26
26	#define KBC_TIMEOUT 250 /* Timeout in ms for sending to keyboard controller */	27	#define KBC_TIMEOUT 250 /* Timeout in ms for sending to keyboard controller */
27		28
Lines 481-488 Link Here
481	return TRUE;	482	return TRUE;
482	}	483	}
483		484
484	Bool	485	static Bool
485	xf86OSKbdPreInit(InputInfoPtr pInfo)	486	stdKbdPreInit(InputInfoPtr pInfo, char *protocol)
486	{	487	{
487	KbdDevPtr pKbd = pInfo->private;	488	KbdDevPtr pKbd = pInfo->private;
488		489
Lines 521-523 Link Here
521	#endif	522	#endif
522	return TRUE;	523	return TRUE;
523	}	524	}
		525
		526	typedef struct _evdevKbdRec {
		527	int packetSize;
		528	char *buffer;
		529	evdevDriver evdev;
		530	} evdevKbdRec, *evdevKbdPtr;
		531
		532	static void
		533	evdevKbdReadInput(InputInfoPtr pInfo)
		534	{
		535	KbdDevPtr pKbd;
		536	evdevKbdPtr evdevKbd;
		537	struct input_event *ev;
		538	int n;
		539	int code;
		540
		541	pKbd = (KbdDevPtr) pInfo->private;
		542	evdevKbd = pKbd->private;
		543	ev = (struct input_event *) evdevKbd->buffer;
		544
		545	if (pInfo->fd == -1)
		546	return;
		547
		548	do {
		549	n = read(pInfo->fd, ev, sizeof(struct input_event));
		550	if (n == -1) {
		551	xf86Msg(X_ERROR, "%s: Error in reading! (%s) Disabiling.\n",
		552	pInfo->name, strerror(errno));
		553	RemoveEnabledDevice(pInfo->fd);
		554	close (pInfo->fd);
		555	pInfo->dev->public.on = FALSE;
		556	pInfo->fd = -1;
		557	return;
		558	}
		559	if (n != sizeof(struct input_event)) {
		560	xf86Msg(X_WARNING, "%s: incomplete packet, size %d\n", pInfo->name, n);
		561	return;
		562	}
		563
		564	switch (ev->type) {
		565	case EV_KEY:
		566	if ((ev->code <= EV_KEY_RESERVED)\|\|(ev->code >= EV_KEY_UNKNOWN))
		567	break;
		568	switch (ev->code) {
		569	case EV_KEY_103RD:
		570	case EV_KEY_102ND:
		571	case EV_KEY_LINEFEED:
		572	case EV_KEY_MACRO:
		573	case EV_KEY_MUTE:
		574	case EV_KEY_VOLUMEDOWN:
		575	case EV_KEY_VOLUMEUP:
		576	case EV_KEY_POWER:
		577	case EV_KEY_KPPLUSMINUS:
		578	case EV_KEY_F18:
		579	case EV_KEY_F19:
		580	case EV_KEY_F20:
		581	case EV_KEY_F21:
		582	case EV_KEY_F22:
		583	case EV_KEY_F23:
		584	case EV_KEY_F24:
		585	case EV_KEY_KPCOMMA:
		586	case EV_KEY_COMPOSE:
		587	code = KEY_UNKNOWN;
		588	break;
589	case EV_KEY_F13:
590	code = KEY_F13;
591	break;
592	case EV_KEY_F14:
593	code = KEY_F14;
594	break;
595	case EV_KEY_F15:
596	code = KEY_F15;
597	break;
598	case EV_KEY_F16:
599	code = KEY_F16;
600	break;
601	case EV_KEY_F17:
602	code = KEY_F17;
603	break;
604	case EV_KEY_KPENTER:
605	code = KEY_KP_Enter;
606	break;
607	case EV_KEY_RIGHTCTRL:
608	code = KEY_RCtrl;
609	break;
610	case EV_KEY_KPSLASH:
611	code = KEY_KP_Divide;
612	break;
613	case EV_KEY_SYSRQ:
614	code = KEY_SysReqest;
615	break;
616	case EV_KEY_RIGHTALT:
617	code = KEY_AltLang;
618	break;
619	case EV_KEY_HOME:
620	code = KEY_Home;
621	break;
622	case EV_KEY_UP:
623	code = KEY_Up;
624	break;
625	case EV_KEY_PAGEUP:
626	code = KEY_PgUp;
627	break;
628	case EV_KEY_LEFT:
629	code = KEY_Left;
630	break;
631	case EV_KEY_RIGHT:
632	code = KEY_Right;
633	break;
634	case EV_KEY_END:
635	code = KEY_End;
636	break;
637	case EV_KEY_DOWN:
638	code = KEY_Down;
639	break;
640	case EV_KEY_PAGEDOWN:
641	code = KEY_PgDown;
642	break;
643	case EV_KEY_INSERT:
644	code = KEY_Insert;
645	break;
646	case EV_KEY_DELETE:
647	code = KEY_Delete;
648	break;
649	case EV_KEY_KPEQUAL:
650	code = KEY_KP_Equal;
651	break;
652	case EV_KEY_PAUSE:
653	code = KEY_Pause;
654	break;
655	case EV_KEY_LEFTMETA:
656	code = KEY_LMeta;
657	break;
658	case EV_KEY_RIGHTMETA:
659	code = KEY_RMeta;
660	break;
661	default:
662	code = ev->code;
663	break;
664	}
665	if (code >= 127)
666	code = KEY_UNKNOWN;
667
668	if (ev->value)
669	pKbd->PostEvent(pInfo, code, TRUE);
670	else
671	pKbd->PostEvent(pInfo, code, FALSE);
672	break;
673	}
674	} while (xf86WaitForInput(pInfo->fd, 0));
675
676	return;
677	}
678
679	static int
680	evdevKbdInit(InputInfoPtr pInfo, int what)
681	{
682	KbdDevPtr pKbd = (KbdDevPtr) pInfo->private;
683	evdevKbdPtr evdevKbd = (evdevKbdPtr) pKbd->private;
684
685	evdevKbd->evdev.name = xf86SetStrOption(pInfo->options,"Dev Name",NULL);
686	evdevKbd->evdev.phys = xf86SetStrOption(pInfo->options,"Dev Phys",NULL);
687	evdevKbd->evdev.cb_data = pInfo->dev;
688	evdevKbd->evdev.callback = pInfo->device_control;
689	if (!evdevNewDriver (&evdevKbd->evdev)) {
690	xf86Msg(X_ERROR, "%s: cannot register with evdev brain\n", pInfo->name);
691	return BadRequest;
692	}
693	if ((pInfo->fd = evdevGetFDForDriver (&evdevKbd->evdev)) == -1) {
694	xf86Msg(X_ERROR, "%s: cannot open input device\n", pInfo->name);
695	return BadRequest;
696	}
697
698	close(pInfo->fd);
699	pInfo->fd = -1;
700
701	return Success;
702	}
703
704	static int
705	evdevKbdOn(InputInfoPtr pInfo, int what)
706	{
707	KbdDevPtr pKbd = (KbdDevPtr) pInfo->private;
708	evdevKbdPtr evdevKbd = (evdevKbdPtr) pKbd->private;
709	unsigned long mask;
710
711	if ((pInfo->fd = evdevGetFDForDriver (&evdevKbd->evdev)) == -1) {
712	xf86Msg(X_ERROR, "%s: cannot open input device (name: '%s', phys: '%s')\n", pInfo->name, evdevKbd->evdev.name, evdevKbd->evdev.phys);
713	return BadRequest;
714	}
715	/*
716	* Grab the keyboard for ourselves.
717	*/
718	if (ioctl(pInfo->fd, EVIOCGMASK, &mask) < 0) {
719	xf86Msg(X_INFO, "%s: unable to use input device masking '%s', trying grabbing.\n", pInfo->name, strerror(errno));
720	if (ioctl(pInfo->fd, EVIOCGRAB, 1) < 0) {
721	xf86Msg(X_ERROR, "%s: unable to grab device '%s', you may have problems.\n", pInfo->name, strerror(errno));
722	}
723	return Success;
724	}
725
726	mask \|= BIT(2);
727	ioctl(pInfo->fd, EVIOCSMASK, mask);
728
729	ioctl(pInfo->fd, EVIOCGDMASK, &mask);
730	mask &= ~BIT(0);
731	mask \|= BIT(2);
732	ioctl(pInfo->fd, EVIOCSDMASK, mask);
733	xf86Msg(X_INFO, "%s: Using input device masking.\n", pInfo->name);
734
735	return Success;
736	}
737
738	static int
739	evdevKbdOff(InputInfoPtr pInfo, int what)
740	{
741	if (pInfo->fd != -1) {
742	unsigned long mask;
743
744	if (ioctl(pInfo->fd, EVIOCGDMASK, &mask) >= 0) {
745	mask \|= BIT(0);
746	ioctl(pInfo->fd, EVIOCSDMASK, mask);
747	}
748
749	close (pInfo->fd);
750	pInfo->fd = -1;
751	}
752	return Success;
753	}
754
755	static void
756	evdevSoundBell(InputInfoPtr pInfo, int loudness, int pitch, int duration)
757	{
758	}
759
760	static void
761	evdevSetKbdLeds(InputInfoPtr pInfo, int leds)
762	{
763	struct input_event event;
764
765	memset(&event, 0, sizeof(event));
766	event.type = EV_LED;
767	event.code = EV_LED_CAPSL;
768	event.value = (leds & XLED1) ? 1 : 0;
769	write(pInfo->fd, (char *) &event, sizeof(event));
770
771	event.type = EV_LED;
772	event.code = EV_LED_NUML;
773	event.value = (leds & XLED2) ? 1 : 0;
774	write(pInfo->fd, (char *) &event, sizeof(event));
775
776	event.type = EV_LED;
777	event.code = EV_LED_SCROLLL;
778	event.value = (leds & XLED3) ? 1 : 0;
779	write(pInfo->fd, (char *) &event, sizeof(event));
780
781	event.type = EV_LED;
782	event.code = EV_LED_COMPOSE;
783	event.value = (leds & XLED4) ? 1 : 0;
784	write(pInfo->fd, (char *) &event, sizeof(event));
785	}
786
787	static int
788	evdevGetKbdLeds(InputInfoPtr pInfo)
789	{
790	unsigned long evleds[NBITS(EV_LED_MAX)];
791	int leds = 0;
792
793	ioctl(pInfo->fd, EVIOCGLED(sizeof(evleds)), &evleds);
794	if (test_bit(EV_LED_CAPSL, evleds))
795	leds \|= XLED1;
796
797	if (test_bit(EV_LED_NUML, evleds))
798	leds \|= XLED2;
799
800	if (test_bit(EV_LED_SCROLLL, evleds))
801	leds \|= XLED3;
802
803	if (test_bit(EV_LED_COMPOSE, evleds))
804	leds \|= XLED4;
805
806	return leds;
807	}
808
809	static void
810	evdevSetKbdRepeat(InputInfoPtr pInfo, char rad)
811	{
812	KbdDevPtr pKbd = (KbdDevPtr) pInfo->private;
813	int rep_info[2];
814
815	rep_info[0] = pKbd->delay;
816	rep_info[1] = pKbd->rate * 10;
817	ioctl(pInfo->fd, EVIOCSREP, rep_info);
818	}
819
820	static int
821	evdevGetSpecialKey(InputInfoPtr pInfo, int scanCode)
822	{
823	return scanCode;
824	}
825
826	static Bool
827	evdevOpenKeyboard(InputInfoPtr pInfo)
828	{
829	return TRUE;
830	}
831
832	static Bool
833	evdevKbdPreInit(InputInfoPtr pInfo, char *protocol)
834	{
835	KbdDevPtr pKbd = pInfo->private;
836	evdevKbdPtr evdevKbd;
837	xf86Msg(X_CONFIG, "%s: Protocol: %s\n", pInfo->name, protocol);
838
839	pKbd->private = evdevKbd = xcalloc(sizeof(evdevKbdRec), 1);
840
841	xf86Msg(X_ERROR, "%s: pInfo->dev: %p\n", pInfo->name, pInfo->dev);
842
843	if (pKbd->private == NULL) {
844	xf86Msg(X_ERROR, "%s: cannot allocate buffer\n", pInfo->name);
845	return FALSE;
846	}
847
848	evdevKbd->buffer = xcalloc(sizeof(struct input_event),1);
849
850	if (evdevKbd->buffer == NULL) {
851	xf86Msg(X_ERROR, "%s: cannot allocate buffer\n", pInfo->name);
852	xfree(evdevKbd);
853	return FALSE;
854	}
855
856	if (!evdevStart (pInfo->drv)) {
857	xf86Msg(X_ERROR, "%s: cannot start evdev brain\n", pInfo->name);
858	xfree(evdevKbd);
859	xfree(evdevKbd->buffer);
860	return FALSE;
861	}
862
863	pKbd->KbdInit = evdevKbdInit;
864	pKbd->KbdOn = evdevKbdOn;
865	pKbd->KbdOff = evdevKbdOff;
866	pKbd->Bell = evdevSoundBell;
867	pKbd->SetLeds = evdevSetKbdLeds;
868	pKbd->GetLeds = evdevGetKbdLeds;
869	pKbd->SetKbdRepeat = evdevSetKbdRepeat;
870	pKbd->KbdGetMapping = KbdGetMapping;
871	pKbd->SpecialKey = SpecialKey;
872
873	pKbd->RemapScanCode = NULL;
874	pKbd->GetSpecialKey = evdevGetSpecialKey;
875
876	pKbd->OpenKeyboard = evdevOpenKeyboard;
877	pKbd->vtSwitchSupported = FALSE;
878	pInfo->read_input = evdevKbdReadInput;
879
880	return TRUE;
881	}
882
883	Bool
884	xf86OSKbdPreInit(InputInfoPtr pInfo)
885	{
886	char *protocol;
887	Bool ret;
888
889	protocol = xf86SetStrOption(pInfo->options, "Protocol", NULL);
890
891	if (!protocol)
892	ret = FALSE;
893	else if (!strcmp(protocol, "standard"))
894	ret = stdKbdPreInit(pInfo, protocol);
895	else if (!strcmp(protocol, "evdev"))
896	ret = evdevKbdPreInit(pInfo, protocol);
897	else
898	ret = FALSE;
899
900	xfree(protocol);
901	return ret;
902	}