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
37static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
38
39static int next_id = 1;
40
41static 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
49static 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
74wait_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) {
111fprintf(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) {
118fprintf(stderr, "ACCESSORY_SEND_HID_EVENT returned %d errno: %d\n", ret, errno);
119            goto wait_for_device;
120        }
121    }
122
123fprintf(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
127fprintf(stderr, "hid thread exiting\n");
128err:
129    return NULL;
130}
131
132static 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 *)(uintptr_t)fd);
143}
144
145static 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
198void init_hid()
199{
200    pthread_t th;
201    pthread_create(&th, NULL, inotify_thread, NULL);
202}
203