Драйвер для ядра 3.x и старше

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <linux/input.h>
#include <linux/uinput.h>
#define NKEY 7
 
int main(void){
    int fd;
    struct uinput_user_dev uidev;
    struct input_event ev;
  int i,n,key_a[NKEY];
  key_a[0] = KEY_0;
  key_a[1] = KEY_1;
  key_a[2] = KEY_2;
  key_a[3] = KEY_3;
  key_a[4] = KEY_4;
  key_a[5] = KEY_5;
  key_a[6] = KEY_ENTER;
 
    fd = open("/dev/uinput", O_WRONLY | O_NONBLOCK);
    if (fd < 0) {
        const int e = errno;
        fprintf(stdout, "fail @ open /dev/uinput : %d : %s",
                e, strerror(e));
        exit(EXIT_FAILURE);
    }
    if (ioctl(fd, UI_SET_EVBIT, EV_KEY) < 0) {
        const int e = errno;
        fprintf(stdout, "fail @ ioctl UI_SET_EVBIT EV_KEY : %d : %s",
                e, strerror(e));
        exit(EXIT_FAILURE);
    }
 
  for(i = 0; i < NKEY; i++){
 
    if (ioctl(fd, UI_SET_KEYBIT, key_a[i]) < 0) {
        const int e = errno;
        fprintf(stdout, "fail @ ioctl UI_SET_KEYBIT KEY_0 : %d : %s",
                e, strerror(e));
        exit(EXIT_FAILURE);
    }
  }
 
    memset(&uidev, 0, sizeof(uidev));
    strcpy(uidev.name, "tmp-input");
    uidev.id.bustype = BUS_I8042;
    uidev.id.vendor  = 0x1;
    uidev.id.product = 0x1;
    uidev.id.version = 1;
    if((n=write(fd, &uidev, sizeof(uidev))) < 0) {
        const int e = errno;
        fprintf(stdout, "fail @ write uidev : %d : %s", e, strerror(e));
        exit(EXIT_FAILURE);
    }
 
    if(ioctl(fd, UI_DEV_CREATE) < 0) {
        const int e = errno;
        fprintf(stdout, "fail @ ioctl UI_DEV_CREATE : %d : %s",
                e, strerror(e));
        exit(EXIT_FAILURE);
    }
 
  for(i = 0; i < NKEY - 1; i++){
    memset(&ev, 0, sizeof(struct input_event));
    ev.type = EV_KEY;
    ev.code = key_a[i];
    ev.value = 1;
    if ((n=write(fd, &ev, sizeof(struct input_event))) < 0) {
        const int e = errno;
        fprintf(stdout, "fail @ write EV_KEY KEY_ESC 1 : %d : %s",
                e, strerror(e));
        exit(EXIT_FAILURE);
    }
    usleep(5000);
 
    memset(&ev, 0, sizeof(struct input_event));
    ev.type = EV_KEY;
    ev.code = key_a[i];
    ev.value = 0;
    if (write(fd, &ev, sizeof(struct input_event)) < 0) {
        const int e = errno;
        fprintf(stdout, "fail @ write EV_KEY KEY_ESC 0 : %d : %s",
                e, strerror(e));
    }
    usleep(5000);
 
    memset(&ev, 0, sizeof(struct input_event));
    ev.type = EV_KEY;
    ev.code = key_a[NKEY - 1];
    ev.value = 1;
    if ((n=write(fd, &ev, sizeof(struct input_event))) < 0) {
        const int e = errno;
        fprintf(stdout, "fail @ write EV_KEY KEY_ESC 1 : %d : %s",
                e, strerror(e));
        exit(EXIT_FAILURE);
    }
    usleep(5000);
 
    memset(&ev, 0, sizeof(struct input_event));
    ev.type = EV_KEY;
    ev.code = key_a[NKEY - 1];
    ev.value = 0;
    if (write(fd, &ev, sizeof(struct input_event)) < 0) {
        const int e = errno;
        fprintf(stdout, "fail @ write EV_KEY KEY_ESC 0 : %d : %s",
                e, strerror(e));
    }
    usleep(200000);
 
  }
 
    if (ioctl(fd, UI_DEV_DESTROY) < 0) {
        const int e = errno;
        fprintf(stdout, "fail @ ioctl UI_DEV_DESTROY : %d : %s",
                e, strerror(e));
    }
 
    close(fd);
    fprintf(stdout, "\nexit: %d\n",i);
 
    return EXIT_SUCCESS;
}

#include "dev.h"
#include "ioctl.h"
 
#define MYEVENT_MAJOR 201
#define MYEVENT_MODNAME "my_event"
 
// Работа с символьным устройством в старом стиле...
static int dev_open( struct inode *n, struct file *f ) {
   // ... при этом MINOR номер устройства должна обслуживать функция open:
   // unsigned int minor = iminor( n );
   return 0;
}
 
static int dev_release( struct inode *n, struct file *f ) {
   return 0;
}
 
static struct input_dev *i_dev;
static char dname[16];
 
static long dev_ioctl( struct file *f,
                      unsigned int cmd, unsigned long arg ) {
int ni, nr, nc, nv;
  nr = 0;
   if( ( _IOC_TYPE( cmd ) != IOC_MAGIC ) ) return -ENOTTY;
   switch( cmd ) {
    case MYEVENT_CMD_KEY:
      ni = copy_from_user( (void *)&data.n, (void *)arg, _IOC_SIZE( cmd ) );
      if(ni != 0){
        nr =  -EFAULT;
        printk(KERN_ERR "my_event from %d\n", ni);
      }
//  printk(KERN_INFO "my_event from %d\n", data.n);
      nc = data.n;
      nv = (nc > 0) ? 1 : 0;
      if(nv == 0)
        nc = -nc;
      input_event(i_dev, EV_KEY, nc, nv);
//    input_event(i_dev, EV_KEY, KEY_ENTER, 1);
      input_sync(i_dev);
      break;
    default: 
     nr =  -ENOTTY;
  }
  return nr;
}
 
static const struct file_operations event_fops = {
   .owner = THIS_MODULE,
   .open = dev_open,
   .release = dev_release,
   .unlocked_ioctl = dev_ioctl
};
 
int init_module(void){
int error;
 
  i_dev = input_allocate_device();
  if (!i_dev) {
    printk(KERN_ERR "my_event.c: Not enough memory\n");
    error = -ENOMEM;
    goto err_err;
  }
 
//  memset(i_dev, 0, sizeof(struct input_dev));
  i_dev->evbit[0] = BIT_MASK(EV_KEY);
  i_dev->keybit[BIT_WORD(KEY_ESC)] = BIT_MASK(KEY_ESC);
  i_dev->keybit[BIT_WORD(KEY_1)] = BIT_MASK(KEY_1);
  i_dev->keybit[BIT_WORD(KEY_2)] = BIT_MASK(KEY_2);
  i_dev->keybit[BIT_WORD(KEY_3)] = BIT_MASK(KEY_3);
  i_dev->keybit[BIT_WORD(KEY_4)] = BIT_MASK(KEY_4);
  i_dev->keybit[BIT_WORD(KEY_5)] = BIT_MASK(KEY_5);
  i_dev->keybit[BIT_WORD(KEY_6)] = BIT_MASK(KEY_6);
  i_dev->keybit[BIT_WORD(KEY_7)] = BIT_MASK(KEY_7);
  i_dev->keybit[BIT_WORD(KEY_8)] = BIT_MASK(KEY_8);
  i_dev->keybit[BIT_WORD(KEY_9)] = BIT_MASK(KEY_9);
  i_dev->keybit[BIT_WORD(KEY_0)] = BIT_MASK(KEY_0);
  i_dev->keybit[BIT_WORD(KEY_MINUS)] = BIT_MASK(KEY_MINUS);
  i_dev->keybit[BIT_WORD(KEY_EQUAL)] = BIT_MASK(KEY_EQUAL);
  i_dev->keybit[BIT_WORD(KEY_BACKSPACE)] = BIT_MASK(KEY_BACKSPACE);
  i_dev->keybit[BIT_WORD(KEY_TAB)] = BIT_MASK(KEY_TAB);
  i_dev->keybit[BIT_WORD(KEY_Q)] = BIT_MASK(KEY_Q);
  i_dev->keybit[BIT_WORD(KEY_W)] = BIT_MASK(KEY_W);
  i_dev->keybit[BIT_WORD(KEY_E)] = BIT_MASK(KEY_E);
  i_dev->keybit[BIT_WORD(KEY_R)] = BIT_MASK(KEY_R);
  i_dev->keybit[BIT_WORD(KEY_T)] = BIT_MASK(KEY_T);
  i_dev->keybit[BIT_WORD(KEY_Y)] = BIT_MASK(KEY_Y);
  i_dev->keybit[BIT_WORD(KEY_U)] = BIT_MASK(KEY_U);
  i_dev->keybit[BIT_WORD(KEY_I)] = BIT_MASK(KEY_I);
  i_dev->keybit[BIT_WORD(KEY_O)] = BIT_MASK(KEY_O);
  i_dev->keybit[BIT_WORD(KEY_P)] = BIT_MASK(KEY_P);
  i_dev->keybit[BIT_WORD(KEY_LEFTBRACE)] = BIT_MASK(KEY_LEFTBRACE);
  i_dev->keybit[BIT_WORD(KEY_RIGHTBRACE)] = BIT_MASK(KEY_RIGHTBRACE);
  i_dev->keybit[BIT_WORD(KEY_ENTER)] = BIT_MASK(KEY_ENTER);
  i_dev->keybit[BIT_WORD(KEY_LEFTCTRL)] = BIT_MASK(KEY_LEFTCTRL);
  i_dev->keybit[BIT_WORD(KEY_A)] = BIT_MASK(KEY_A);
  i_dev->keybit[BIT_WORD(KEY_S)] = BIT_MASK(KEY_S);
  i_dev->keybit[BIT_WORD(KEY_D)] = BIT_MASK(KEY_D);
  i_dev->keybit[BIT_WORD(KEY_F)] = BIT_MASK(KEY_F);
  i_dev->keybit[BIT_WORD(KEY_G)] = BIT_MASK(KEY_G);
  i_dev->keybit[BIT_WORD(KEY_H)] = BIT_MASK(KEY_H);
  i_dev->keybit[BIT_WORD(KEY_J)] = BIT_MASK(KEY_J);
  i_dev->keybit[BIT_WORD(KEY_K)] = BIT_MASK(KEY_K);
  i_dev->keybit[BIT_WORD(KEY_L)] = BIT_MASK(KEY_L);
  i_dev->keybit[BIT_WORD(KEY_SEMICOLON)] = BIT_MASK(KEY_SEMICOLON);
  i_dev->keybit[BIT_WORD(KEY_APOSTROPHE)] = BIT_MASK(KEY_APOSTROPHE);
  i_dev->keybit[BIT_WORD(KEY_GRAVE)] = BIT_MASK(KEY_GRAVE);
  i_dev->keybit[BIT_WORD(KEY_LEFTSHIFT)] = BIT_MASK(KEY_LEFTSHIFT);
  i_dev->keybit[BIT_WORD(KEY_BACKSLASH)] = BIT_MASK(KEY_BACKSLASH);
  i_dev->keybit[BIT_WORD(KEY_Z)] = BIT_MASK(KEY_Z);
  i_dev->keybit[BIT_WORD(KEY_X)] = BIT_MASK(KEY_X);
  i_dev->keybit[BIT_WORD(KEY_C)] = BIT_MASK(KEY_C);
  i_dev->keybit[BIT_WORD(KEY_V)] = BIT_MASK(KEY_V);
  i_dev->keybit[BIT_WORD(KEY_B)] = BIT_MASK(KEY_B);
  i_dev->keybit[BIT_WORD(KEY_N)] = BIT_MASK(KEY_N);
  i_dev->keybit[BIT_WORD(KEY_M)] = BIT_MASK(KEY_M);
  i_dev->keybit[BIT_WORD(KEY_COMMA)] = BIT_MASK(KEY_COMMA);
  i_dev->keybit[BIT_WORD(KEY_DOT)] = BIT_MASK(KEY_DOT);
  i_dev->keybit[BIT_WORD(KEY_SLASH)] = BIT_MASK(KEY_SLASH);
  i_dev->keybit[BIT_WORD(KEY_RIGHTSHIFT)] = BIT_MASK(KEY_RIGHTSHIFT);
  i_dev->keybit[BIT_WORD(KEY_LEFTALT)] = BIT_MASK(KEY_LEFTALT);
  i_dev->keybit[BIT_WORD(KEY_SPACE)] = BIT_MASK(KEY_SPACE);
  i_dev->keybit[BIT_WORD(KEY_CAPSLOCK)] = BIT_MASK(KEY_CAPSLOCK);
  i_dev->keybit[BIT_WORD(KEY_F1)] = BIT_MASK(KEY_F1);
  i_dev->keybit[BIT_WORD(KEY_F2)] = BIT_MASK(KEY_F2);
  i_dev->keybit[BIT_WORD(KEY_F3)] = BIT_MASK(KEY_F3);
  i_dev->keybit[BIT_WORD(KEY_F4)] = BIT_MASK(KEY_F4);
  i_dev->keybit[BIT_WORD(KEY_F5)] = BIT_MASK(KEY_F5);
  i_dev->keybit[BIT_WORD(KEY_F6)] = BIT_MASK(KEY_F6);
  i_dev->keybit[BIT_WORD(KEY_F7)] = BIT_MASK(KEY_F7);
  i_dev->keybit[BIT_WORD(KEY_F8)] = BIT_MASK(KEY_F8);
  i_dev->keybit[BIT_WORD(KEY_F9)] = BIT_MASK(KEY_F9);
  i_dev->keybit[BIT_WORD(KEY_F10)] = BIT_MASK(KEY_F10);
  i_dev->keybit[BIT_WORD(KEY_F11)] = BIT_MASK(KEY_F11);
  i_dev->keybit[BIT_WORD(KEY_F12)] = BIT_MASK(KEY_F12);
  i_dev->keybit[BIT_WORD(KEY_UP)] = BIT_MASK(KEY_UP);
  i_dev->keybit[BIT_WORD(KEY_PAGEUP)] = BIT_MASK(KEY_PAGEUP);
  i_dev->keybit[BIT_WORD(KEY_LEFT)] = BIT_MASK(KEY_LEFT);
  i_dev->keybit[BIT_WORD(KEY_RIGHT)] = BIT_MASK(KEY_RIGHT);
  i_dev->keybit[BIT_WORD(KEY_DOWN)] = BIT_MASK(KEY_DOWN);
  i_dev->keybit[BIT_WORD(KEY_PAGEDOWN)] = BIT_MASK(KEY_PAGEDOWN);
 
  strcpy(dname, "my_event");
  i_dev->name = dname;
  i_dev->id.bustype = BUS_I8042;
  i_dev->id.vendor = 1;
  i_dev->id.product = 1;
  i_dev->id.version = 1;
 
  error = input_register_device(i_dev);
  if (error) {
    printk(KERN_ERR "my_event.c: Failed to register device. %d\n", error);
    input_free_device(i_dev);
    goto err_err;
  }
 
   error = register_chrdev( MYEVENT_MAJOR, MYEVENT_MODNAME, &event_fops );
    if( error < 0 ) {
      printk( KERN_ERR "my_event_dev: can't register char device. %d\n", error );
      input_free_device(i_dev);
      goto err_err;
    } else
      printk( KERN_INFO "my_event_dev loaded.\n" );
 
    return 0;
 
err_err:
    return error;
}
 
void cleanup_module( void ) {
  input_unregister_device(i_dev);
  input_free_device(i_dev);
  unregister_chrdev( MYEVENT_MAJOR, MYEVENT_MODNAME );
  printk( KERN_INFO "my_event_dev removed.\n" );
}

#include <linux/fs.h>
#include <linux/init.h>
#include <linux/module.h>
#include <asm/uaccess.h>
#include "user_buf.h"
#include <linux/errno.h>
#include <linux/input.h>
#include <linux/fcntl.h>
#include <uapi/linux/ioctl.h>
 
MODULE_LICENSE( "GPL" );
MODULE_AUTHOR( "Peter Irich <author@prov.ru>" );
MODULE_VERSION( "1.0" );
 
static struct USER_DATA data;
static char name[32];
 
int init_module( void );
 
void cleanup_module( void );

#define IOC_MAGIC    'o'
#define MYEVENT_CMD_KEY _IOR( IOC_MAGIC, 31, int )
 
#define DEVPATH "/dev/my_event"

typedef struct USER_DATA {
   char buf[ 160 ];
  int n;
} USER_DATA;