1 /*
2 * Copyright (C) 2012 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <unistd.h>
18 #include <stdio.h>
19 #include <string.h>
20 #include <stdlib.h>
21
22 #include <sys/types.h>
23 #include <sys/stat.h>
24 #include <sys/ioctl.h>
25 #include <fcntl.h>
26 #include <errno.h>
27 #include <pthread.h>
28 #include <time.h>
29
30 #include <sys/inotify.h>
31 #include <linux/hidraw.h>
32 #include <usbhost/usbhost.h>
33
34 #include "f_accessory.h"
35 #include "accessory.h"
36
37 static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
38
39 static int next_id = 1;
40
milli_sleep(int millis)41 static void milli_sleep(int millis) {
42 struct timespec tm;
43
44 tm.tv_sec = 0;
45 tm.tv_nsec = millis * 1000000;
46 nanosleep(&tm, NULL);
47 }
48
hid_thread(void * arg)49 static void* hid_thread(void* arg) {
50 int fd = (int)arg;
51 char buffer[4096];
52 int id, ret, offset;
53 struct usb_device *device;
54 struct usb_device_descriptor *device_desc;
55 int max_packet;
56 struct hidraw_report_descriptor desc;
57 int desc_length;
58
59 fprintf(stderr, "hid_thread start fd: %d\n", fd);
60
61 if (ioctl(fd, HIDIOCGRDESCSIZE, &desc_length)) {
62 fprintf(stderr, "HIDIOCGRDESCSIZE failed\n");
63 close(fd);
64 goto err;
65 }
66
67 desc.size = HID_MAX_DESCRIPTOR_SIZE - 1;
68 if (ioctl(fd, HIDIOCGRDESC, &desc)) {
69 fprintf(stderr, "HIDIOCGRDESC failed\n");
70 close(fd);
71 goto err;
72 }
73
74 wait_for_device:
75 fprintf(stderr, "waiting for device fd: %d\n", fd);
76 device = usb_wait_for_device();
77 max_packet = usb_device_get_device_descriptor(device)->bMaxPacketSize0;
78 // FIXME
79 max_packet--;
80
81 // FIXME
82 milli_sleep(500);
83
84 pthread_mutex_lock(&mutex);
85 id = next_id++;
86
87 ret = usb_device_control_transfer(device, USB_DIR_OUT | USB_TYPE_VENDOR,
88 ACCESSORY_REGISTER_HID, id, desc_length, NULL, 0, 1000);
89 fprintf(stderr, "ACCESSORY_REGISTER_HID returned %d\n", ret);
90
91 // FIXME
92 milli_sleep(500);
93
94 for (offset = 0; offset < desc_length; ) {
95 int count = desc_length - offset;
96 if (count > max_packet) count = max_packet;
97
98 fprintf(stderr, "sending ACCESSORY_SET_HID_REPORT_DESC offset: %d count: %d desc_length: %d\n",
99 offset, count, desc_length);
100 ret = usb_device_control_transfer(device, USB_DIR_OUT | USB_TYPE_VENDOR,
101 ACCESSORY_SET_HID_REPORT_DESC, id, offset, &desc.value[offset], count, 1000);
102 fprintf(stderr, "ACCESSORY_SET_HID_REPORT_DESC returned %d errno %d\n", ret, errno);
103 offset += count;
104 }
105
106 pthread_mutex_unlock(&mutex);
107
108 while (1) {
109 ret = read(fd, buffer, sizeof(buffer));
110 if (ret < 0) {
111 fprintf(stderr, "read failed, errno: %d, fd: %d\n", errno, fd);
112 break;
113 }
114
115 ret = usb_device_control_transfer(device, USB_DIR_OUT | USB_TYPE_VENDOR,
116 ACCESSORY_SEND_HID_EVENT, id, 0, buffer, ret, 1000);
117 if (ret < 0 && errno != EPIPE) {
118 fprintf(stderr, "ACCESSORY_SEND_HID_EVENT returned %d errno: %d\n", ret, errno);
119 goto wait_for_device;
120 }
121 }
122
123 fprintf(stderr, "ACCESSORY_UNREGISTER_HID\n");
124 ret = usb_device_control_transfer(device, USB_DIR_OUT | USB_TYPE_VENDOR,
125 ACCESSORY_UNREGISTER_HID, id, 0, NULL, 0, 1000);
126
127 fprintf(stderr, "hid thread exiting\n");
128 err:
129 return NULL;
130 }
131
open_hid(const char * name)132 static void open_hid(const char* name)
133 {
134 char path[100];
135
136 snprintf(path, sizeof(path), "/dev/%s", name);
137 int fd = open(path, O_RDWR);
138 if (fd < 0) return;
139
140 fprintf(stderr, "opened /dev/%s\n", name);
141 pthread_t th;
142 pthread_create(&th, NULL, hid_thread, (void *)fd);
143 }
144
inotify_thread(void * arg)145 static void* inotify_thread(void* arg)
146 {
147 open_hid("hidraw0");
148 open_hid("hidraw1");
149 open_hid("hidraw2");
150 open_hid("hidraw3");
151 open_hid("hidraw4");
152 open_hid("hidraw5");
153 open_hid("hidraw6");
154 open_hid("hidraw7");
155 open_hid("hidraw8");
156 open_hid("hidraw9");
157
158 int inotify_fd = inotify_init();
159 inotify_add_watch(inotify_fd, "/dev", IN_DELETE | IN_CREATE);
160
161 while (1) {
162 char event_buf[512];
163 struct inotify_event *event;
164 int event_pos = 0;
165 int event_size;
166
167 int count = read(inotify_fd, event_buf, sizeof(event_buf));
168 if (count < (int)sizeof(*event)) {
169 if(errno == EINTR)
170 continue;
171 fprintf(stderr, "could not get event, %s\n", strerror(errno));
172 break;
173 }
174 while (count >= (int)sizeof(*event)) {
175 event = (struct inotify_event *)(event_buf + event_pos);
176 //fprintf(stderr, "%d: %08x \"%s\"\n", event->wd, event->mask,
177 // event->len ? event->name : "");
178 if (event->len) {
179 if(event->mask & IN_CREATE) {
180 fprintf(stderr, "created %s\n", event->name);
181 // FIXME
182 milli_sleep(50);
183 open_hid(event->name);
184 } else {
185 fprintf(stderr, "lost %s\n", event->name);
186 }
187 }
188 event_size = sizeof(*event) + event->len;
189 count -= event_size;
190 event_pos += event_size;
191 }
192 }
193
194 close(inotify_fd);
195 return NULL;
196 }
197
init_hid()198 void init_hid()
199 {
200 pthread_t th;
201 pthread_create(&th, NULL, inotify_thread, NULL);
202 }
203