evemu

Merge lp:~oif-team/evemu/trunk.prop into lp:evemu

  1. trunk.prop
  2. Merge into trunk
Proposed by Henrik Rydberg
Status: Merged
Merged at revision: 11
Proposed branch: lp:~oif-team/evemu/trunk.prop
Merge into: lp:evemu
Diff against target: 450 lines (+199/-66)
6 files modified
include/evemu.h (+15/-20)
src/evemu-impl.h (+20/-0)
src/evemu.c (+112/-11)
tools/evemu-describe.c (+12/-7)
tools/evemu-device.c (+28/-20)
tools/evemu-echo.c (+12/-8)
To merge this branch: bzr merge lp:~oif-team/evemu/trunk.prop
Reviewer Review Type Date Requested Status
Chase Douglas (community) Approve
Review via email: mp+44372@code.launchpad.net

Description of the change

Support the upcoming device properties.

To post a comment you must log in.
Revision history for this message
Chase Douglas (chasedouglas) wrote :

Seems good.

review: Approve

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
=== modified file 'include/evemu.h'
--- include/evemu.h 2010-09-18 17:10:11 +0000
+++ include/evemu.h 2010-12-21 17:21:49 +0000
@@ -26,28 +26,23 @@
26 *26 *
27 ****************************************************************************/27 ****************************************************************************/
2828
29#ifndef _EVPLAY_H29#ifndef _EVEMU_H
30#define _EVPLAY_H30#define _EVEMU_H
3131
32#include <linux/uinput.h>
33#include <stdio.h>32#include <stdio.h>
3433#include <errno.h>
35#define EVPLAY_NBITS KEY_CNT34#include <linux/input.h>
36#define EVPLAY_NBYTES ((EVPLAY_NBITS + 7) / 8)35
3736#define EVEMU_VERSION_MAJOR 1
38struct evemu_device {37#define EVEMU_VERSION_MINOR 1
39 char name[UINPUT_MAX_NAME_SIZE];38
40 struct input_id id;39struct evemu_device *evemu_new(const char *name);
41 unsigned char mask[EV_CNT][EVPLAY_NBYTES];40void evemu_delete(struct evemu_device *dev);
42 int bytes[EV_CNT];41
43 struct input_absinfo abs[ABS_CNT];42const char *evemu_get_name(const struct evemu_device *dev);
44};43
4544int evemu_has_prop(const struct evemu_device *dev, int code);
46static inline int evemu_has(const struct evemu_device *dev,45int evemu_has_event(const struct evemu_device *dev, int type, int code);
47 int type, int code)
48{
49 return (dev->mask[type][code >> 3] >> (code & 7)) & 1;
50}
5146
52int evemu_extract(struct evemu_device *dev, int fd);47int evemu_extract(struct evemu_device *dev, int fd);
53int evemu_write(const struct evemu_device *dev, FILE *fp);48int evemu_write(const struct evemu_device *dev, FILE *fp);
5449
=== added file 'src/evemu-impl.h'
--- src/evemu-impl.h 1970-01-01 00:00:00 +0000
+++ src/evemu-impl.h 2010-12-21 17:21:49 +0000
@@ -0,0 +1,20 @@
1#ifndef _EVEMU_IMPL_H
2#define _EVEMU_IMPL_H
3
4#include <evemu.h>
5#include <linux/uinput.h>
6
7#define EVPLAY_NBITS KEY_CNT
8#define EVPLAY_NBYTES ((EVPLAY_NBITS + 7) / 8)
9
10struct evemu_device {
11 int version_major, version_minor;
12 char name[UINPUT_MAX_NAME_SIZE];
13 struct input_id id;
14 unsigned char prop[EVPLAY_NBYTES];
15 unsigned char mask[EV_CNT][EVPLAY_NBYTES];
16 int pbytes, mbytes[EV_CNT];
17 struct input_absinfo abs[ABS_CNT];
18};
19
20#endif
021
=== modified file 'src/evemu.c'
--- src/evemu.c 2010-09-19 07:54:48 +0000
+++ src/evemu.c 2010-12-21 17:21:49 +0000
@@ -26,13 +26,25 @@
26 *26 *
27 ****************************************************************************/27 ****************************************************************************/
2828
29#include "evemu.h"29#include "evemu-impl.h"
30#include <stdlib.h>
30#include <string.h>31#include <string.h>
31#include <stdio.h>32#include <stdio.h>
32#include <fcntl.h>33#include <fcntl.h>
33#include <errno.h>34#include <errno.h>
34#include <poll.h>35#include <poll.h>
3536
37#ifndef UI_SET_PROPBIT
38#define UI_SET_PROPBIT _IOW(UINPUT_IOCTL_BASE, 110, int)
39#define EVIOCGPROP(len) _IOC(_IOC_READ, 'E', 0x09, len)
40#define INPUT_PROP_POINTER 0x00
41#define INPUT_PROP_DIRECT 0x01
42#define INPUT_PROP_BUTTONPAD 0x02
43#define INPUT_PROP_SEMI_MT 0x03
44#define INPUT_PROP_MAX 0x1f
45#define INPUT_PROP_CNT (INPUT_PROP_MAX + 1)
46#endif
47
36#define SYSCALL(call) while (((call) == -1) && (errno == EINTR))48#define SYSCALL(call) while (((call) == -1) && (errno == EINTR))
3749
38static void copy_bits(unsigned char *mask, const unsigned long *bits, int bytes)50static void copy_bits(unsigned char *mask, const unsigned long *bits, int bytes)
@@ -44,6 +56,39 @@
44 }56 }
45}57}
4658
59struct evemu_device *evemu_new(const char *name)
60{
61 struct evemu_device *dev = calloc(1, sizeof(struct evemu_device));
62
63 dev->version_major = EVEMU_VERSION_MAJOR;
64 dev->version_minor = EVEMU_VERSION_MINOR;
65
66 if (name && strlen(name) < sizeof(dev->name))
67 strcpy(dev->name, name);
68
69 return dev;
70}
71
72void evemu_delete(struct evemu_device *dev)
73{
74 free(dev);
75}
76
77const char *evemu_get_name(const struct evemu_device *dev)
78{
79 return dev->name;
80}
81
82int evemu_has_prop(const struct evemu_device *dev, int code)
83{
84 return (dev->prop[code >> 3] >> (code & 7)) & 1;
85}
86
87int evemu_has_event(const struct evemu_device *dev, int type, int code)
88{
89 return (dev->mask[type][code >> 3] >> (code & 7)) & 1;
90}
91
47int evemu_extract(struct evemu_device *dev, int fd)92int evemu_extract(struct evemu_device *dev, int fd)
48{93{
49 unsigned long bits[64];94 unsigned long bits[64];
@@ -62,16 +107,22 @@
62 if (rc < 0)107 if (rc < 0)
63 return rc;108 return rc;
64109
110 SYSCALL(rc = ioctl(fd, EVIOCGPROP(sizeof(bits)), bits));
111 if (rc >= 0) {
112 copy_bits(dev->prop, bits, rc);
113 dev->pbytes = rc;
114 }
115
65 for (i = 0; i < EV_CNT; i++) {116 for (i = 0; i < EV_CNT; i++) {
66 SYSCALL(rc = ioctl(fd, EVIOCGBIT(i, sizeof(bits)), bits));117 SYSCALL(rc = ioctl(fd, EVIOCGBIT(i, sizeof(bits)), bits));
67 if (rc < 0)118 if (rc < 0)
68 continue;119 continue;
69 copy_bits(dev->mask[i], bits, rc);120 copy_bits(dev->mask[i], bits, rc);
70 dev->bytes[i] = rc;121 dev->mbytes[i] = rc;
71 }122 }
72123
73 for (i = 0; i < ABS_CNT; i++) {124 for (i = 0; i < ABS_CNT; i++) {
74 if (!evemu_has(dev, EV_ABS, i))125 if (!evemu_has_event(dev, EV_ABS, i))
75 continue;126 continue;
76 SYSCALL(rc = ioctl(fd, EVIOCGABS(i), &dev->abs[i]));127 SYSCALL(rc = ioctl(fd, EVIOCGABS(i), &dev->abs[i]));
77 if (rc < 0)128 if (rc < 0)
@@ -81,6 +132,15 @@
81 return 0;132 return 0;
82}133}
83134
135static void write_prop(FILE * fp, const unsigned char *mask, int bytes)
136{
137 int i;
138 for (i = 0; i < bytes; i += 8)
139 fprintf(fp, "P: %02x %02x %02x %02x %02x %02x %02x %02x\n",
140 mask[i], mask[i + 1], mask[i + 2], mask[i + 3],
141 mask[i + 4], mask[i + 5], mask[i + 6], mask[i + 7]);
142}
143
84static void write_mask(FILE * fp, int index,144static void write_mask(FILE * fp, int index,
85 const unsigned char *mask, int bytes)145 const unsigned char *mask, int bytes)
86{146{
@@ -107,14 +167,28 @@
107 dev->id.bustype, dev->id.vendor,167 dev->id.bustype, dev->id.vendor,
108 dev->id.product, dev->id.version);168 dev->id.product, dev->id.version);
109169
170 write_prop(fp, dev->prop, dev->pbytes);
171
110 for (i = 0; i < EV_CNT; i++)172 for (i = 0; i < EV_CNT; i++)
111 write_mask(fp, i, dev->mask[i], dev->bytes[i]);173 write_mask(fp, i, dev->mask[i], dev->mbytes[i]);
112174
113 for (i = 0; i < ABS_CNT; i++)175 for (i = 0; i < ABS_CNT; i++)
114 if (evemu_has(dev, EV_ABS, i))176 if (evemu_has_event(dev, EV_ABS, i))
115 write_abs(fp, i, &dev->abs[i]);177 write_abs(fp, i, &dev->abs[i]);
116}178}
117179
180static void read_prop(struct evemu_device *dev, FILE *fp)
181{
182 unsigned int mask[8];
183 int i;
184 while (fscanf(fp, "P: %02x %02x %02x %02x %02x %02x %02x %02x\n",
185 mask + 0, mask + 1, mask + 2, mask + 3,
186 mask + 4, mask + 5, mask + 6, mask + 7) > 0) {
187 for (i = 0; i < 8; i++)
188 dev->prop[dev->pbytes++] = mask[i];
189 }
190}
191
118static void read_mask(struct evemu_device *dev, FILE *fp)192static void read_mask(struct evemu_device *dev, FILE *fp)
119{193{
120 unsigned int mask[8];194 unsigned int mask[8];
@@ -123,7 +197,7 @@
123 &index, mask + 0, mask + 1, mask + 2, mask + 3,197 &index, mask + 0, mask + 1, mask + 2, mask + 3,
124 mask + 4, mask + 5, mask + 6, mask + 7) > 0) {198 mask + 4, mask + 5, mask + 6, mask + 7) > 0) {
125 for (i = 0; i < 8; i++)199 for (i = 0; i < 8; i++)
126 dev->mask[index][dev->bytes[index]++] = mask[i];200 dev->mask[index][dev->mbytes[index]++] = mask[i];
127 }201 }
128}202}
129203
@@ -157,6 +231,8 @@
157 dev->id.product = product;231 dev->id.product = product;
158 dev->id.version = version;232 dev->id.version = version;
159233
234 read_prop(dev, fp);
235
160 read_mask(dev, fp);236 read_mask(dev, fp);
161237
162 read_abs(dev, fp);238 read_abs(dev, fp);
@@ -225,7 +301,14 @@
225 return 0;301 return 0;
226}302}
227303
228static int set_bit(int fd, int type, int code)304static int set_prop_bit(int fd, int code)
305{
306 int ret;
307 SYSCALL(ret = ioctl(fd, UI_SET_PROPBIT, code));
308 return ret;
309}
310
311static int set_event_bit(int fd, int type, int code)
229{312{
230 int ret = 0;313 int ret = 0;
231314
@@ -262,14 +345,28 @@
262 return ret;345 return ret;
263}346}
264347
348static int set_prop(const struct evemu_device *dev, int fd)
349{
350 int bits = 8 * dev->pbytes;
351 int ret, i;
352 for (i = 0; i < bits; i++) {
353 if (!evemu_has_prop(dev, i))
354 continue;
355 ret = set_prop_bit(fd, i);
356 if (ret < 0)
357 return ret;
358 }
359 return 0;
360}
361
265static int set_mask(const struct evemu_device *dev, int type, int fd)362static int set_mask(const struct evemu_device *dev, int type, int fd)
266{363{
267 int bits = 8 * dev->bytes[type];364 int bits = 8 * dev->mbytes[type];
268 int ret, i;365 int ret, i;
269 for (i = 0; i < bits; i++) {366 for (i = 0; i < bits; i++) {
270 if (!evemu_has(dev, type, i))367 if (!evemu_has_event(dev, type, i))
271 continue;368 continue;
272 ret = set_bit(fd, type, i);369 ret = set_event_bit(fd, type, i);
273 if (ret < 0)370 if (ret < 0)
274 return ret;371 return ret;
275 }372 }
@@ -285,7 +382,7 @@
285 memcpy(udev.name, dev->name, sizeof(udev.name));382 memcpy(udev.name, dev->name, sizeof(udev.name));
286 udev.id = dev->id;383 udev.id = dev->id;
287 for (i = 0; i < ABS_CNT; i++) {384 for (i = 0; i < ABS_CNT; i++) {
288 if (!evemu_has(dev, EV_ABS, i))385 if (!evemu_has_event(dev, EV_ABS, i))
289 continue;386 continue;
290 udev.absmax[i] = dev->abs[i].maximum;387 udev.absmax[i] = dev->abs[i].maximum;
291 udev.absmin[i] = dev->abs[i].minimum;388 udev.absmin[i] = dev->abs[i].minimum;
@@ -293,6 +390,10 @@
293 udev.absflat[i] = dev->abs[i].flat;390 udev.absflat[i] = dev->abs[i].flat;
294 }391 }
295392
393 ret = set_prop(dev, fd);
394 if (ret < 0)
395 return ret;
396
296 for (i = 0; i < EV_CNT; i++) {397 for (i = 0; i < EV_CNT; i++) {
297 ret = set_mask(dev, i, fd);398 ret = set_mask(dev, i, fd);
298 if (ret < 0)399 if (ret < 0)
299400
=== modified file 'tools/evemu-describe.c'
--- tools/evemu-describe.c 2010-09-18 17:10:11 +0000
+++ tools/evemu-describe.c 2010-12-21 17:21:49 +0000
@@ -26,22 +26,27 @@
26 *26 *
27 ****************************************************************************/27 ****************************************************************************/
2828
29#include "evemu.h"29#include <evemu.h>
30#include <stdio.h>30#include <stdio.h>
31#include <fcntl.h>31#include <fcntl.h>
32#include <string.h>32#include <string.h>
3333
34static int describe_device(int fd)34static int describe_device(int fd)
35{35{
36 struct evemu_device dev;36 struct evemu_device *dev;
37 int ret;37 int ret = -ENOMEM;
3838
39 ret = evemu_extract(&dev, fd);39 dev = evemu_new(0);
40 if (!dev)
41 goto out;
42 ret = evemu_extract(dev, fd);
40 if (ret)43 if (ret)
41 return ret;44 goto out;
42 evemu_write(&dev, stdout);
4345
44 return 0;46 evemu_write(dev, stdout);
47out:
48 evemu_delete(dev);
49 return ret;
45}50}
4651
47int main(int argc, char *argv[])52int main(int argc, char *argv[])
4853
=== modified file 'tools/evemu-device.c'
--- tools/evemu-device.c 2010-09-23 15:53:46 +0000
+++ tools/evemu-device.c 2010-12-21 17:21:49 +0000
@@ -50,7 +50,7 @@
50 ret = read(fd, name, sizeof(name));50 ret = read(fd, name, sizeof(name));
51 if (ret > 0)51 if (ret > 0)
52 name[ret - 1] = 0;52 name[ret - 1] = 0;
53 if (!strcmp(dev->name, name))53 if (!strcmp(evemu_get_name(dev), name))
54 sprintf(node, "/dev/input/event%d", i + 1);54 sprintf(node, "/dev/input/event%d", i + 1);
55 close(fd);55 close(fd);
56 }56 }
@@ -58,7 +58,7 @@
58 fd = open(node, O_RDONLY);58 fd = open(node, O_RDONLY);
59 if (fd < 0)59 if (fd < 0)
60 return;60 return;
61 fprintf(stdout, "%s: %s\n", dev->name, node);61 fprintf(stdout, "%s: %s\n", evemu_get_name(dev), node);
62 fflush(stdout);62 fflush(stdout);
63 while ((ret = read(fd, data, sizeof(data))) > 0);63 while ((ret = read(fd, data, sizeof(data))) > 0);
64 close(fd);64 close(fd);
@@ -66,28 +66,36 @@
6666
67static int evemu_device(FILE *fp)67static int evemu_device(FILE *fp)
68{68{
69 struct evemu_device dev;69 struct evemu_device *dev;
70 int ret, fd;70 char name[64];
7171 int ret = -ENOMEM;
72 ret = evemu_read(&dev, fp);72 int fd;
73
74 sprintf(name, "evemu-%d", getpid());
75
76 dev = evemu_new(name);
77 if (!dev)
78 goto out;
79 ret = evemu_read(dev, fp);
73 if (ret <= 0)80 if (ret <= 0)
74 return ret;81 goto out;
7582
76 sprintf(dev.name, "evemu-%d", getpid());83 ret = fd = open(UINPUT_NODE, O_WRONLY);
7784 if (ret < 0)
78 fd = open(UINPUT_NODE, O_WRONLY);85 goto out;
79 if (fd < 0)86
80 return fd;87 ret = evemu_create(dev, fd);
81 ret = evemu_create(&dev, fd);88 if (ret < 0)
82 if (ret < 0)89 goto out_close;
83 return ret;90 hold_device(dev);
84
85 hold_device(&dev);
86
87 evemu_destroy(fd);91 evemu_destroy(fd);
92
93out_close:
88 close(fd);94 close(fd);
95out:
96 evemu_delete(dev);
8997
90 return 0;98 return ret;
91}99}
92100
93int main(int argc, char *argv[])101int main(int argc, char *argv[])
94102
=== modified file 'tools/evemu-echo.c'
--- tools/evemu-echo.c 2010-09-18 17:10:11 +0000
+++ tools/evemu-echo.c 2010-12-21 17:21:49 +0000
@@ -33,16 +33,20 @@
3333
34static int evemu_echo_describe(FILE *fp)34static int evemu_echo_describe(FILE *fp)
35{35{
36 struct evemu_device dev;36 struct evemu_device *dev;
37 int ret;37 int ret = -ENOMEM;
3838
39 ret = evemu_read(&dev, fp);39 dev = evemu_new(0);
40 if (!dev)
41 goto out;
42 ret = evemu_read(dev, fp);
40 if (ret <= 0)43 if (ret <= 0)
41 return ret;44 goto out;
4245
43 evemu_write(&dev, stdout);46 evemu_write(dev, stdout);
4447out:
45 return 0;48 evemu_delete(dev);
49 return ret;
46}50}
4751
48static int evemu_echo_event(FILE *fp)52static int evemu_echo_event(FILE *fp)

Subscribers

People subscribed via source and target branches

to all changes: