linux下usb gadget 模拟键盘

分类： LINUX

平台：Ti am3517

内核：linux 2.6.37

在内核配置中选中gadget中的HID device

修改 kernel-2.6.37/drivers/usb/gadget/hid.c  加入设备注册 

点击(此处)折叠或打开

1. /*
   
2.  * hid.c -- HID Composite driver
   
3.  *
   
4.  * Based on multi.c
   
5.  *
   
6.  * Copyright (C) 2010 Fabien Chouteau <fabien.chouteau@barco.com>
   
7.  *
   
8.  * This program is free software; you can redistribute it and/or modify
   
9.  * it under the terms of the GNU General Public License as published by
   
10.  * the Free Software Foundation; either version 2 of the License, or
    
11.  * (at your option) any later version.
    
12.  *
    
13.  * This program is distributed in the hope that it will be useful,
    
14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
    
15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    
16.  * GNU General Public License for more details.
    
17.  *
    
18.  * You should have received a copy of the GNU General Public License
    
19.  * along with this program; if not, write to the Free Software
    
20.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
    
21.  */
    
22. 
    
23. 
    
24. #include <linux/kernel.h>
    
25. #include <linux/platform_device.h>
    
26. #include <linux/list.h>
    
27. #include <linux/usb/g_hid.h>
    
28. #define DRIVER_DESC        "HID Gadget"
    
29. #define DRIVER_VERSION        "2010/03/16"
    
30. 
    
31. /*-------------------------------------------------------------------------*/
    
32. 
    
33. #define HIDG_VENDOR_NUM        0x0525    /* XXX NetChip */
    
34. #define HIDG_PRODUCT_NUM    0xa4ac    /* Linux-USB HID gadget */
    
35. 
    
36. /*-------------------------------------------------------------------------*/
    
37. 
    
38. /*
    
39.  * kbuild is not very cooperative with respect to linking separately
    
40.  * compiled library objects into one module. So for now we won't use
    
41.  * separate compilation ... ensuring init/exit sections work to shrink
    
42.  * the runtime footprint, and giving us at least some parts of what
    
43.  * a "gcc --combine ... part1.c part2.c part3.c ... " build would.
    
44.  */
    
45. 
    
46. #include "composite.c"
    
47. #include "usbstring.c"
    
48. #include "config.c"
    
49. #include "epautoconf.c"
    
50. 
    
51. #include "f_hid.c"
    
52. 
    
53. 
    
54. 
    
55. /* hid descriptor for a keyboard */
    
56. static struct hidg_func_descriptor my_hid_data = {
    
57.     .subclass        = 0, /* No subclass */
    
58.     .protocol        = 1, /* Keyboard */
    
59.     .report_length        = 8,
    
60.     .report_desc_length    = 63,
    
61.     .report_desc        = {
    
62.         0x05, 0x01,    /* USAGE_PAGE (Generic Desktop)     */
    
63.         0x09, 0x06,    /* USAGE (Keyboard) */
    
64.         0xa1, 0x01,    /* COLLECTION (Application) */
    
65.         0x05, 0x07,    /* USAGE_PAGE (Keyboard) */
    
66.         0x19, 0xe0,    /* USAGE_MINIMUM (Keyboard LeftControl) */
    
67.         0x29, 0xe7,    /* USAGE_MAXIMUM (Keyboard Right GUI) */
    
68.         0x15, 0x00,    /* LOGICAL_MINIMUM (0) */
    
69.         0x25, 0x01,    /* LOGICAL_MAXIMUM (1) */
    
70.         0x75, 0x01,    /* REPORT_SIZE (1) */
    
71.         0x95, 0x08,    /* REPORT_COUNT (8) */
    
72.         0x81, 0x02,    /* INPUT (Data,Var,Abs) */
    
73.         0x95, 0x01,    /* REPORT_COUNT (1) */
    
74.         0x75, 0x08,    /* REPORT_SIZE (8) */
    
75.         0x81, 0x03,    /* INPUT (Cnst,Var,Abs) */
    
76.         0x95, 0x05,    /* REPORT_COUNT (5) */
    
77.         0x75, 0x01,    /* REPORT_SIZE (1) */
    
78.         0x05, 0x08,    /* USAGE_PAGE (LEDs) */
    
79.         0x19, 0x01,    /* USAGE_MINIMUM (Num Lock) */
    
80.         0x29, 0x05,    /* USAGE_MAXIMUM (Kana) */
    
81.         0x91, 0x02,    /* OUTPUT (Data,Var,Abs) */
    
82.         0x95, 0x01,    /* REPORT_COUNT (1) */
    
83.         0x75, 0x03,    /* REPORT_SIZE (3) */
    
84.         0x91, 0x03,    /* OUTPUT (Cnst,Var,Abs) */
    
85.         0x95, 0x06,    /* REPORT_COUNT (6) */
    
86.         0x75, 0x08,    /* REPORT_SIZE (8) */
    
87.         0x15, 0x00,    /* LOGICAL_MINIMUM (0) */
    
88.         0x25, 0x65,    /* LOGICAL_MAXIMUM (101) */
    
89.         0x05, 0x07,    /* USAGE_PAGE (Keyboard) */
    
90.         0x19, 0x00,    /* USAGE_MINIMUM (Reserved) */
    
91.         0x29, 0x65,    /* USAGE_MAXIMUM (Keyboard Application) */
    
92.         0x81, 0x00,    /* INPUT (Data,Ary,Abs) */
    
93.         0xc0        /* END_COLLECTION */
    
94.     }
    
95. };
    
96. 
    
97. struct hidg_func_node {
    
98.     struct list_head node;
    
99.     struct hidg_func_descriptor *func;
    
100. };
     
101. 
     
102. static LIST_HEAD(hidg_func_list);
     
103. 
     
104. /*-------------------------------------------------------------------------*/
     
105. 
     
106. static struct usb_device_descriptor device_desc = {
     
107.     .bLength =        sizeof device_desc,
     
108.     .bDescriptorType =    USB_DT_DEVICE,
     
109. 
     
110.     .bcdUSB =        cpu_to_le16(0x0200),
     
111. 
     
112.     /* .bDeviceClass =        USB_CLASS_COMM, */
     
113.     /* .bDeviceSubClass =    0, */
     
114.     /* .bDeviceProtocol =    0, */
     
115.     .bDeviceClass =        0xEF,
     
116.     .bDeviceSubClass =    2,
     
117.     .bDeviceProtocol =    1,
     
118.     /* .bMaxPacketSize0 = f(hardware) */
     
119. 
     
120.     /* Vendor and product id can be overridden by module parameters. */
     
121.     .idVendor =        cpu_to_le16(HIDG_VENDOR_NUM),
     
122.     .idProduct =        cpu_to_le16(HIDG_PRODUCT_NUM),
     
123.     /* .bcdDevice = f(hardware) */
     
124.     /* .iManufacturer = DYNAMIC */
     
125.     /* .iProduct = DYNAMIC */
     
126.     /* NO SERIAL NUMBER */
     
127.     .bNumConfigurations =    1,
     
128. };
     
129. 
     
130. static struct usb_otg_descriptor otg_descriptor = {
     
131.     .bLength =        sizeof otg_descriptor,
     
132.     .bDescriptorType =    USB_DT_OTG,
     
133. 
     
134.     /* REVISIT SRP-only hardware is possible, although
     
135.      * it would not be called "OTG" ...
     
136.      */
     
137.     .bmAttributes =        USB_OTG_SRP | USB_OTG_HNP,
     
138. };
     
139. 
     
140. static const struct usb_descriptor_header *otg_desc[] = {
     
141.     (struct usb_descriptor_header *) &otg_descriptor,
     
142.     NULL,
     
143. };
     
144. 
     
145. 
     
146. /* string IDs are assigned dynamically */
     
147. 
     
148. #define STRING_MANUFACTURER_IDX        0
     
149. #define STRING_PRODUCT_IDX        1
     
150. 
     
151. static char manufacturer[50];
     
152. 
     
153. static struct usb_string strings_dev[] = {
     
154.     [STRING_MANUFACTURER_IDX].s = manufacturer,
     
155.     [STRING_PRODUCT_IDX].s = DRIVER_DESC,
     
156.     { } /* end of list */
     
157. };
     
158. 
     
159. static struct usb_gadget_strings stringtab_dev = {
     
160.     .language    = 0x0409,    /* en-us */
     
161.     .strings    = strings_dev,
     
162. };
     
163. 
     
164. static struct usb_gadget_strings *dev_strings[] = {
     
165.     &stringtab_dev,
     
166.     NULL,
     
167. };
     
168. 
     
169. 
     
170. 
     
171. /****************************** Configurations ******************************/
     
172. 
     
173. static int __init do_config(struct usb_configuration *c)
     
174. {
     
175.     struct hidg_func_node *e;
     
176.     int func = 0, status = 0;
     
177. 
     
178.     if (gadget_is_otg(c->cdev->gadget)) {
     
179.         c->descriptors = otg_desc;
     
180.         c->bmAttributes |= USB_CONFIG_ATT_WAKEUP;
     
181.     }
     
182. 
     
183.     list_for_each_entry(e, &hidg_func_list, node) {
     
184.         status = hidg_bind_config(c, e->func, func++);
     
185.         if (status)
     
186.             break;
     
187.     }
     
188. 
     
189.     return status;
     
190. }
     
191. 
     
192. static struct usb_configuration config_driver = {
     
193.     .label            = "HID Gadget",
     
194.     .bConfigurationValue    = 1,
     
195.     /* .iConfiguration = DYNAMIC */
     
196.     .bmAttributes        = USB_CONFIG_ATT_SELFPOWER,
     
197. };
     
198. 
     
199. /****************************** Gadget Bind ******************************/
     
200. 
     
201. static int __init hid_bind(struct usb_composite_dev *cdev)
     
202. {
     
203.     struct usb_gadget *gadget = cdev->gadget;
     
204.     struct list_head *tmp;
     
205.     int status, gcnum, funcs = 0;
     
206. 
     
207.     list_for_each(tmp, &hidg_func_list)
     
208.         funcs++;
     
209. 
     
210.     if (!funcs)
     
211.         return -ENODEV;
     
212. 
     
213.     /* set up HID */
     
214.     status = ghid_setup(cdev->gadget, funcs);
     
215.     if (status < 0)
     
216.         return status;
     
217. 
     
218.     gcnum = usb_gadget_controller_number(gadget);
     
219.     if (gcnum >= 0)
     
220.         device_desc.bcdDevice = cpu_to_le16(0x0300 | gcnum);
     
221.     else
     
222.         device_desc.bcdDevice = cpu_to_le16(0x0300 | 0x0099);
     
223. 
     
224. 
     
225.     /* Allocate string descriptor numbers ... note that string
     
226.      * contents can be overridden by the composite_dev glue.
     
227.      */
     
228. 
     
229.     /* device descriptor strings: manufacturer, product */
     
230.     snprintf(manufacturer, sizeof manufacturer, "%s %s with %s",
     
231.         init_utsname()->sysname, init_utsname()->release,
     
232.         gadget->name);
     
233.     status = usb_string_id(cdev);
     
234.     if (status < 0)
     
235.         return status;
     
236.     strings_dev[STRING_MANUFACTURER_IDX].id = status;
     
237.     device_desc.iManufacturer = status;
     
238. 
     
239.     status = usb_string_id(cdev);
     
240.     if (status < 0)
     
241.         return status;
     
242.     strings_dev[STRING_PRODUCT_IDX].id = status;
     
243.     device_desc.iProduct = status;
     
244. 
     
245.     /* register our configuration */
     
246.     status = usb_add_config(cdev, &config_driver, do_config);
     
247.     if (status < 0)
     
248.         return status;
     
249. 
     
250.     dev_info(&gadget->dev, DRIVER_DESC ", version: " DRIVER_VERSION "\n");
     
251. 
     
252.     return 0;
     
253. }
     
254. 
     
255. static int __exit hid_unbind(struct usb_composite_dev *cdev)
     
256. {
     
257.     ghid_cleanup();
     
258.     return 0;
     
259. }
     
260. 
     
261. static int __init hidg_plat_driver_probe(struct platform_device *pdev)
     
262. {
     
263.     struct hidg_func_descriptor *func = pdev->dev.platform_data;
     
264.     struct hidg_func_node *entry;
     
265. 
     
266.     if (!func) {
     
267.         dev_err(&pdev->dev, "Platform data missing\n");
     
268.         return -ENODEV;
     
269.     }
     
270. 
     
271.     entry = kzalloc(sizeof(*entry), GFP_KERNEL);
     
272.     if (!entry)
     
273.         return -ENOMEM;
     
274. 
     
275.     entry->func = func;
     
276.     list_add_tail(&entry->node, &hidg_func_list);
     
277. 
     
278.     return 0;
     
279. }
     
280. 
     
281. static int __devexit hidg_plat_driver_remove(struct platform_device *pdev)
     
282. {
     
283.     struct hidg_func_node *e, *n;
     
284. 
     
285.     list_for_each_entry_safe(e, n, &hidg_func_list, node) {
     
286.         list_del(&e->node);
     
287.         kfree(e);
     
288.     }
     
289. 
     
290.     return 0;
     
291. }
     
292. 
     
293. 
     
294. /****************************** Some noise ******************************/
     
295. //add wds
     
296. static struct platform_device my_hid = {
     
297.     .name = "hidg",
     
298.     .id            = 0,
     
299.     .num_resources = 0,
     
300.     .resource    = 0,
     
301.     .dev.platform_data = &my_hid_data,
     
302. };
     
303. //add end
     
304. 
     
305. static struct usb_composite_driver hidg_driver = {
     
306.     .name        = "g_hid",
     
307.     .dev        = &device_desc,
     
308.     .strings    = dev_strings,
     
309.     .unbind        = __exit_p(hid_unbind),
     
310. };
     
311. 
     
312. static struct platform_driver hidg_plat_driver = {
     
313.     .remove        = __devexit_p(hidg_plat_driver_remove),
     
314.     .driver        = {
     
315.         .owner    = THIS_MODULE,
     
316.         .name    = "hidg",
     
317.     },
     
318. };
     
319. 
     
320. 
     
321. MODULE_DESCRIPTION(DRIVER_DESC);
     
322. MODULE_AUTHOR("Fabien Chouteau, Peter Korsgaard");
     
323. MODULE_LICENSE("GPL");
     
324. 
     
325. static int __init hidg_init(void)
     
326. {
     
327.     int status;
     
328.     //add wds
     
329.     status = platform_device_register(&my_hid);
     
330.     if (status < 0)
     
331.     {
     
332.         platform_driver_unregister(&my_hid);
     
333.         return status;
     
334.     }
     
335.     //add end
     
336.     status = platform_driver_probe(&hidg_plat_driver,
     
337.                 hidg_plat_driver_probe);
     
338.     if (status < 0)
     
339.     {
     
340.             printk("platform_driver_probe:*****wrong\n");
     
341.             return status;
     
342.     }
     
343.     status = usb_composite_probe(&hidg_driver, hid_bind);
     
344.     if (status < 0)
     
345.         platform_driver_unregister(&hidg_plat_driver);
     
346. 
     
347.     return status;
     
348. }
     
349. module_init(hidg_init);
     
350. 
     
351. static void __exit hidg_cleanup(void)
     
352. {
     
353.     platform_device_unregister(&my_hid);
     
354.     platform_driver_unregister(&hidg_plat_driver);
     
355.     usb_composite_unregister(&hidg_driver);
     
356. }
     
357. module_exit(hidg_cleanup);

测试程序 

HID_TEST.c 

点击(此处)折叠或打开

1. #include <pthread.h>
   
2. #include <string.h>
   
3. #include <stdio.h>
   
4. #include <ctype.h>
   
5. #include <fcntl.h>
   
6. #include <errno.h>
   
7. #include <stdio.h>
   
8. #include <stdlib.h>
   
9. #include <unistd.h>
   
10.     
    
11. #define BUF_LEN 512
    
12. 
    
13. struct options {
    
14.     const char *opt;
    
15.     unsigned char val;
    
16. };
    
17. 
    
18. static struct options kmod[] = {
    
19.     {.opt = "--left-ctrl",        .val = 0x01},
    
20.     {.opt = "--right-ctrl",        .val = 0x10},
    
21.     {.opt = "--left-shift",        .val = 0x02},
    
22.     {.opt = "--right-shift",    .val = 0x20},
    
23.     {.opt = "--left-alt",        .val = 0x04},
    
24.     {.opt = "--right-alt",        .val = 0x40},
    
25.     {.opt = "--left-meta",        .val = 0x08},
    
26.     {.opt = "--right-meta",        .val = 0x80},
    
27.     {.opt = NULL}
    
28. };
    
29.     
    
30. static struct options kval[] = {
    
31.     {.opt = "--return",    .val = 0x28},
    
32.     {.opt = "--esc",    .val = 0x29},
    
33.     {.opt = "--bckspc",    .val = 0x2a},
    
34.     {.opt = "--tab",    .val = 0x2b},
    
35.     {.opt = "--spacebar",    .val = 0x2c},
    
36.     {.opt = "--caps-lock",    .val = 0x39},
    
37.     {.opt = "--f1",        .val = 0x3a},
    
38.     {.opt = "--f2",        .val = 0x3b},
    
39.     {.opt = "--f3",        .val = 0x3c},
    
40.     {.opt = "--f4",        .val = 0x3d},
    
41.     {.opt = "--f5",        .val = 0x3e},
    
42.     {.opt = "--f6",        .val = 0x3f},
    
43.     {.opt = "--f7",        .val = 0x40},
    
44.     {.opt = "--f8",        .val = 0x41},
    
45.     {.opt = "--f9",        .val = 0x42},
    
46.     {.opt = "--f10",    .val = 0x43},
    
47.     {.opt = "--f11",    .val = 0x44},
    
48.     {.opt = "--f12",    .val = 0x45},
    
49.     {.opt = "--insert",    .val = 0x49},
    
50.     {.opt = "--home",    .val = 0x4a},
    
51.     {.opt = "--pageup",    .val = 0x4b},
    
52.     {.opt = "--del",    .val = 0x4c},
    
53.     {.opt = "--end",    .val = 0x4d},
    
54.     {.opt = "--pagedown",    .val = 0x4e},
    
55.     {.opt = "--right",    .val = 0x4f},
    
56.     {.opt = "--left",    .val = 0x50},
    
57.     {.opt = "--down",    .val = 0x51},
    
58.     {.opt = "--kp-enter",    .val = 0x58},
    
59.     {.opt = "--up",        .val = 0x52},
    
60.     {.opt = "--num-lock",    .val = 0x53},
    
61.     {.opt = NULL}
    
62. };
    
63.     
    
64. int keyboard_fill_report(char report[8], char buf[BUF_LEN], int *hold)
    
65. {
    
66.     char *tok = strtok(buf, " ");
    
67.     int key = 0;
    
68.     int i = 0;
    
69.     
    
70.     for (; tok != NULL; tok = strtok(NULL, " ")) {
    
71.     
    
72.         if (strcmp(tok, "--quit") == 0)
    
73.             return -1;
    
74. 
    
75.         if (strcmp(tok, "--hold") == 0) {
    
76.             *hold = 1;
    
77.             continue;
    
78.         }
    
79. 
    
80.         if (key < 6) {
    
81.             for (i = 0; kval[i].opt != NULL; i++)
    
82.                 if (strcmp(tok, kval[i].opt) == 0) {
    
83.                     report[2 + key++] = kval[i].val;
    
84.                     break;
    
85.                 }
    
86.             if (kval[i].opt != NULL)
    
87.                 continue;
    
88.         }
    
89. 
    
90.         if (key < 6)
    
91.             if (islower(tok[0])) {
    
92.                 report[2 + key++] = (tok[0] - ('a' - 0x04));
    
93.                 continue;
    
94.             }
    
95. 
    
96.         for (i = 0; kmod[i].opt != NULL; i++)
    
97.             if (strcmp(tok, kmod[i].opt) == 0) {
    
98.                 report[0] = report[0] | kmod[i].val;
    
99.                 break;
    
100.             }
     
101.         if (kmod[i].opt != NULL)
     
102.             continue;
     
103. 
     
104.         if (key < 6)
     
105.             fprintf(stderr, "unknown option: %s\n", tok);
     
106.     }
     
107.     return 8;
     
108. }
     
109. static struct options mmod[] = {
     
110.     {.opt = "--b1", .val = 0x01},
     
111.     {.opt = "--b2", .val = 0x02},
     
112.     {.opt = "--b3", .val = 0x04},
     
113.     {.opt = NULL}
     
114. };
     
115. 
     
116. int mouse_fill_report(char report[8], char buf[BUF_LEN], int *hold)
     
117. {
     
118.     char *tok = strtok(buf, " ");
     
119.     int mvt = 0;
     
120.     int i = 0;
     
121.     for (; tok != NULL; tok = strtok(NULL, " ")) {
     
122. 
     
123.         if (strcmp(tok, "--quit") == 0)
     
124.             return -1;
     
125. 
     
126.         if (strcmp(tok, "--hold") == 0) {
     
127.             *hold = 1;
     
128.             continue;
     
129.         }
     
130. 
     
131.         for (i = 0; mmod[i].opt != NULL; i++)
     
132.             if (strcmp(tok, mmod[i].opt) == 0) {
     
133.                 report[0] = report[0] | mmod[i].val;
     
134.                 break;
     
135.             }
     
136.         if (mmod[i].opt != NULL)
     
137.             continue;
     
138. 
     
139.         if (!(tok[0] == '-' && tok[1] == '-') && mvt < 2) {
     
140.             errno = 0;
     
141.             report[1 + mvt++] = (char)strtol(tok, NULL, 0);
     
142.             if (errno != 0) {
     
143.                 fprintf(stderr, "Bad value:'%s'\n", tok);
     
144.                 report[1 + mvt--] = 0;
     
145.             }
     
146.             continue;
     
147.         }
     
148. 
     
149.         fprintf(stderr, "unknown option: %s\n", tok);
     
150.     }
     
151.     return 3;
     
152. }
     
153. 
     
154. static struct options jmod[] = {
     
155.     {.opt = "--b1",        .val = 0x10},
     
156.     {.opt = "--b2",        .val = 0x20},
     
157.     {.opt = "--b3",        .val = 0x40},
     
158.     {.opt = "--b4",        .val = 0x80},
     
159.     {.opt = "--hat1",    .val = 0x00},
     
160.     {.opt = "--hat2",    .val = 0x01},
     
161.     {.opt = "--hat3",    .val = 0x02},
     
162.     {.opt = "--hat4",    .val = 0x03},
     
163.     {.opt = "--hatneutral",    .val = 0x04},
     
164.     {.opt = NULL}
     
165. };
     
166. 
     
167. int joystick_fill_report(char report[8], char buf[BUF_LEN], int *hold)
     
168. {
     
169.     char *tok = strtok(buf, " ");
     
170.     int mvt = 0;
     
171.     int i = 0;
     
172.     
     
173.     *hold = 1;
     
174. 
     
175.     /* set default hat position: neutral */
     
176.     report[3] = 0x04;
     
177. 
     
178.     for (; tok != NULL; tok = strtok(NULL, " ")) {
     
179.         if (strcmp(tok, "--quit") == 0)
     
180.             return -1;
     
181. 
     
182.         for (i = 0; jmod[i].opt != NULL; i++)
     
183.             if (strcmp(tok, jmod[i].opt) == 0) {
     
184.                 report[3] = (report[3] & 0xF0) | jmod[i].val;
     
185.                 break;
     
186.             }
     
187.         if (jmod[i].opt != NULL)
     
188.             continue;
     
189. 
     
190.         if (!(tok[0] == '-' && tok[1] == '-') && mvt < 3) {
     
191.             errno = 0;
     
192.             report[mvt++] = (char)strtol(tok, NULL, 0);
     
193.             if (errno != 0) {
     
194.                 fprintf(stderr, "Bad value:'%s'\n", tok);
     
195.                 report[mvt--] = 0;
     
196.             }
     
197.             continue;
     
198.         }
     
199. 
     
200.         fprintf(stderr, "unknown option: %s\n", tok);
     
201.     }
     
202.     return 4;
     
203. }
     
204. 
     
205. void print_options(char c)
     
206. {
     
207.     int i = 0;
     
208. 
     
209.     if (c == 'k') {
     
210.         printf("    keyboard options:\n"
     
211.          "        --hold\n");
     
212.         for (i = 0; kmod[i].opt != NULL; i++)
     
213.             printf("\t\t%s\n", kmod[i].opt);
     
214.         printf("\n    keyboard values:\n"
     
215.          "        [a-z] or\n");
     
216.         for (i = 0; kval[i].opt != NULL; i++)
     
217.             printf("\t\t%-8s%s", kval[i].opt, i % 2 ? "\n" : "");
     
218.         printf("\n");
     
219.     } else if (c == 'm') {
     
220.         printf("    mouse options:\n"
     
221.          "        --hold\n");
     
222.         for (i = 0; mmod[i].opt != NULL; i++)
     
223.             printf("\t\t%s\n", mmod[i].opt);
     
224.         printf("\n    mouse values:\n"
     
225.          "        Two signed numbers\n"
     
226.          "--quit to close\n");
     
227.     } else {
     
228.         printf("    joystick options:\n");
     
229.         for (i = 0; jmod[i].opt != NULL; i++)
     
230.             printf("\t\t%s\n", jmod[i].opt);
     
231.         printf("\n    joystick values:\n"
     
232.          "        three signed numbers\n"
     
233.          "--quit to close\n");
     
234.     }
     
235. }
     
236. 
     
237. int main(int argc, const char *argv[])
     
238. {
     
239.     const char *filename = NULL;
     
240.     int fd = 0;
     
241.     char buf[BUF_LEN];
     
242.     int cmd_len;
     
243.     char report[8];
     
244.     int to_send = 8;
     
245.     int hold = 0;
     
246.     fd_set rfds;
     
247.     int retval, i;
     
248. 
     
249.     if (argc < 3) {
     
250.         fprintf(stderr, "Usage: %s devname mouse|keyboard|joystick\n",
     
251.             argv[0]);
     
252.         return 1;
     
253.     }
     
254. 
     
255.     if (argv[2][0] != 'k' && argv[2][0] != 'm' && argv[2][0] != 'j')
     
256.      return 2;
     
257. 
     
258.     filename = argv[1];
     
259.     if ((fd = open(filename, O_RDWR, 0666)) == -1) {
     
260.         perror(filename);
     
261.         return 3;
     
262.     }
     
263. 
     
264.     print_options(argv[2][0]);
     
265. 
     
266.     while (42) {
     
267. 
     
268.         FD_ZERO(&rfds);
     
269.         FD_SET(STDIN_FILENO, &rfds);
     
270.         FD_SET(fd, &rfds);
     
271. 
     
272.         retval = select(fd + 1, &rfds, NULL, NULL, NULL);
     
273.         if (retval == -1 && errno == EINTR)
     
274.             continue;
     
275.         if (retval < 0) {
     
276.             perror("select()");
     
277.             return 4;
     
278.         }
     
279. 
     
280.         if (FD_ISSET(fd, &rfds)) {
     
281.             cmd_len = read(fd, buf, BUF_LEN - 1);
     
282.             printf("recv report:");
     
283.             for (i = 0; i < cmd_len; i++)
     
284.                 printf(" %02x", buf[i]);
     
285.             printf("\n");
     
286.         }
     
287. 
     
288.         if (FD_ISSET(STDIN_FILENO, &rfds)) {
     
289.             memset(report, 0x0, sizeof(report));
     
290.             cmd_len = read(STDIN_FILENO, buf, BUF_LEN - 1);
     
291. 
     
292.             if (cmd_len == 0)
     
293.                 break;
     
294. 
     
295.             buf[cmd_len - 1] = '\0';
     
296.             hold = 0;
     
297. 
     
298.             memset(report, 0x0, sizeof(report));
     
299.             if (argv[2][0] == 'k')
     
300.                 to_send = keyboard_fill_report(report, buf, &hold);
     
301.             else if (argv[2][0] == 'm')
     
302.                 to_send = mouse_fill_report(report, buf, &hold);
     
303.             else
     
304.                 to_send = joystick_fill_report(report, buf, &hold);
     
305. 
     
306.             if (to_send == -1)
     
307.                 break;
     
308. 
     
309.             if (write(fd, report, to_send) != to_send) {
     
310.                 perror(filename);
     
311.                 return 5;
     
312.             }
     
313.             if (!hold) {
     
314.                 memset(report, 0x0, sizeof(report));
     
315.                 if (write(fd, report, to_send) != to_send) {
     
316.                     perror(filename);
     
317.                     return 6;
     
318.                 }
     
319.             }
     
320.         }
     
321.     }
     
322.     
     
323.     close(fd);
     
324.     return 0;
     
325. }