2 HIDP implementation for Linux Bluetooth stack (BlueZ).
3 Copyright (C) 2003-2004 Marcel Holtmann <marcel@holtmann.org>
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License version 2 as
7 published by the Free Software Foundation;
9 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
10 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
11 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
12 IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
13 CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
14 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
19 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
20 SOFTWARE IS DISCLAIMED.
23 #include <linux/module.h>
25 #include <linux/types.h>
26 #include <linux/errno.h>
27 #include <linux/kernel.h>
28 #include <linux/sched.h>
29 #include <linux/slab.h>
30 #include <linux/poll.h>
31 #include <linux/freezer.h>
32 #include <linux/fcntl.h>
33 #include <linux/skbuff.h>
34 #include <linux/socket.h>
35 #include <linux/ioctl.h>
36 #include <linux/file.h>
37 #include <linux/init.h>
38 #include <linux/wait.h>
39 #include <linux/mutex.h>
40 #include <linux/kthread.h>
43 #include <linux/input.h>
44 #include <linux/hid.h>
45 #include <linux/hidraw.h>
47 #include <net/bluetooth/bluetooth.h>
48 #include <net/bluetooth/hci_core.h>
49 #include <net/bluetooth/l2cap.h>
55 static DECLARE_RWSEM(hidp_session_sem);
56 static LIST_HEAD(hidp_session_list);
58 static unsigned char hidp_keycode[256] = {
59 0, 0, 0, 0, 30, 48, 46, 32, 18, 33, 34, 35, 23, 36,
60 37, 38, 50, 49, 24, 25, 16, 19, 31, 20, 22, 47, 17, 45,
61 21, 44, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 28, 1,
62 14, 15, 57, 12, 13, 26, 27, 43, 43, 39, 40, 41, 51, 52,
63 53, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 87, 88,
64 99, 70, 119, 110, 102, 104, 111, 107, 109, 106, 105, 108, 103, 69,
65 98, 55, 74, 78, 96, 79, 80, 81, 75, 76, 77, 71, 72, 73,
66 82, 83, 86, 127, 116, 117, 183, 184, 185, 186, 187, 188, 189, 190,
67 191, 192, 193, 194, 134, 138, 130, 132, 128, 129, 131, 137, 133, 135,
68 136, 113, 115, 114, 0, 0, 0, 121, 0, 89, 93, 124, 92, 94,
69 95, 0, 0, 0, 122, 123, 90, 91, 85, 0, 0, 0, 0, 0,
70 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
71 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
72 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
73 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
74 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
75 29, 42, 56, 125, 97, 54, 100, 126, 164, 166, 165, 163, 161, 115,
76 114, 113, 150, 158, 159, 128, 136, 177, 178, 176, 142, 152, 173, 140
79 static unsigned char hidp_mkeyspat[] = { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 };
81 static struct hidp_session *__hidp_get_session(bdaddr_t *bdaddr)
83 struct hidp_session *session;
88 list_for_each(p, &hidp_session_list) {
89 session = list_entry(p, struct hidp_session, list);
90 if (!bacmp(bdaddr, &session->bdaddr))
96 static void __hidp_link_session(struct hidp_session *session)
98 __module_get(THIS_MODULE);
99 list_add(&session->list, &hidp_session_list);
101 hci_conn_hold_device(session->conn);
104 static void __hidp_unlink_session(struct hidp_session *session)
106 hci_conn_put_device(session->conn);
108 list_del(&session->list);
109 module_put(THIS_MODULE);
112 static void __hidp_copy_session(struct hidp_session *session, struct hidp_conninfo *ci)
114 memset(ci, 0, sizeof(*ci));
115 bacpy(&ci->bdaddr, &session->bdaddr);
117 ci->flags = session->flags;
118 ci->state = session->state;
121 ci->product = 0x0000;
122 ci->version = 0x0000;
124 if (session->input) {
125 ci->vendor = session->input->id.vendor;
126 ci->product = session->input->id.product;
127 ci->version = session->input->id.version;
128 if (session->input->name)
129 strncpy(ci->name, session->input->name, 128);
131 strncpy(ci->name, "HID Boot Device", 128);
135 ci->vendor = session->hid->vendor;
136 ci->product = session->hid->product;
137 ci->version = session->hid->version;
138 strncpy(ci->name, session->hid->name, 128);
142 static int hidp_queue_event(struct hidp_session *session, struct input_dev *dev,
143 unsigned int type, unsigned int code, int value)
145 unsigned char newleds;
148 BT_DBG("session %p type %d code %d value %d", session, type, code, value);
153 newleds = (!!test_bit(LED_KANA, dev->led) << 3) |
154 (!!test_bit(LED_COMPOSE, dev->led) << 3) |
155 (!!test_bit(LED_SCROLLL, dev->led) << 2) |
156 (!!test_bit(LED_CAPSL, dev->led) << 1) |
157 (!!test_bit(LED_NUML, dev->led));
159 if (session->leds == newleds)
162 session->leds = newleds;
164 skb = alloc_skb(3, GFP_ATOMIC);
166 BT_ERR("Can't allocate memory for new frame");
170 *skb_put(skb, 1) = HIDP_TRANS_DATA | HIDP_DATA_RTYPE_OUPUT;
171 *skb_put(skb, 1) = 0x01;
172 *skb_put(skb, 1) = newleds;
174 skb_queue_tail(&session->intr_transmit, skb);
176 hidp_schedule(session);
181 static int hidp_hidinput_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
183 struct hid_device *hid = input_get_drvdata(dev);
184 struct hidp_session *session = hid->driver_data;
186 return hidp_queue_event(session, dev, type, code, value);
189 static int hidp_input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
191 struct hidp_session *session = input_get_drvdata(dev);
193 return hidp_queue_event(session, dev, type, code, value);
196 static void hidp_input_report(struct hidp_session *session, struct sk_buff *skb)
198 struct input_dev *dev = session->input;
199 unsigned char *keys = session->keys;
200 unsigned char *udata = skb->data + 1;
201 signed char *sdata = skb->data + 1;
202 int i, size = skb->len - 1;
204 switch (skb->data[0]) {
205 case 0x01: /* Keyboard report */
206 for (i = 0; i < 8; i++)
207 input_report_key(dev, hidp_keycode[i + 224], (udata[0] >> i) & 1);
209 /* If all the key codes have been set to 0x01, it means
210 * too many keys were pressed at the same time. */
211 if (!memcmp(udata + 2, hidp_mkeyspat, 6))
214 for (i = 2; i < 8; i++) {
215 if (keys[i] > 3 && memscan(udata + 2, keys[i], 6) == udata + 8) {
216 if (hidp_keycode[keys[i]])
217 input_report_key(dev, hidp_keycode[keys[i]], 0);
219 BT_ERR("Unknown key (scancode %#x) released.", keys[i]);
222 if (udata[i] > 3 && memscan(keys + 2, udata[i], 6) == keys + 8) {
223 if (hidp_keycode[udata[i]])
224 input_report_key(dev, hidp_keycode[udata[i]], 1);
226 BT_ERR("Unknown key (scancode %#x) pressed.", udata[i]);
230 memcpy(keys, udata, 8);
233 case 0x02: /* Mouse report */
234 input_report_key(dev, BTN_LEFT, sdata[0] & 0x01);
235 input_report_key(dev, BTN_RIGHT, sdata[0] & 0x02);
236 input_report_key(dev, BTN_MIDDLE, sdata[0] & 0x04);
237 input_report_key(dev, BTN_SIDE, sdata[0] & 0x08);
238 input_report_key(dev, BTN_EXTRA, sdata[0] & 0x10);
240 input_report_rel(dev, REL_X, sdata[1]);
241 input_report_rel(dev, REL_Y, sdata[2]);
244 input_report_rel(dev, REL_WHEEL, sdata[3]);
251 static int __hidp_send_ctrl_message(struct hidp_session *session,
252 unsigned char hdr, unsigned char *data, int size)
256 BT_DBG("session %p data %p size %d", session, data, size);
258 skb = alloc_skb(size + 1, GFP_ATOMIC);
260 BT_ERR("Can't allocate memory for new frame");
264 *skb_put(skb, 1) = hdr;
265 if (data && size > 0)
266 memcpy(skb_put(skb, size), data, size);
268 skb_queue_tail(&session->ctrl_transmit, skb);
273 static inline int hidp_send_ctrl_message(struct hidp_session *session,
274 unsigned char hdr, unsigned char *data, int size)
278 err = __hidp_send_ctrl_message(session, hdr, data, size);
280 hidp_schedule(session);
285 static int hidp_queue_report(struct hidp_session *session,
286 unsigned char *data, int size)
290 BT_DBG("session %p hid %p data %p size %d", session, session->hid, data, size);
292 skb = alloc_skb(size + 1, GFP_ATOMIC);
294 BT_ERR("Can't allocate memory for new frame");
298 *skb_put(skb, 1) = 0xa2;
300 memcpy(skb_put(skb, size), data, size);
302 skb_queue_tail(&session->intr_transmit, skb);
304 hidp_schedule(session);
309 static int hidp_send_report(struct hidp_session *session, struct hid_report *report)
311 unsigned char buf[32];
314 rsize = ((report->size - 1) >> 3) + 1 + (report->id > 0);
315 if (rsize > sizeof(buf))
318 hid_output_report(report, buf);
320 return hidp_queue_report(session, buf, rsize);
323 static int hidp_get_raw_report(struct hid_device *hid,
324 unsigned char report_number,
325 unsigned char *data, size_t count,
326 unsigned char report_type)
328 struct hidp_session *session = hid->driver_data;
331 int numbered_reports = hid->report_enum[report_type].numbered;
333 switch (report_type) {
334 case HID_FEATURE_REPORT:
335 report_type = HIDP_TRANS_GET_REPORT | HIDP_DATA_RTYPE_FEATURE;
337 case HID_INPUT_REPORT:
338 report_type = HIDP_TRANS_GET_REPORT | HIDP_DATA_RTYPE_INPUT;
340 case HID_OUTPUT_REPORT:
341 report_type = HIDP_TRANS_GET_REPORT | HIDP_DATA_RTYPE_OUPUT;
347 if (mutex_lock_interruptible(&session->report_mutex))
350 /* Set up our wait, and send the report request to the device. */
351 session->waiting_report_type = report_type & HIDP_DATA_RTYPE_MASK;
352 session->waiting_report_number = numbered_reports ? report_number : -1;
353 set_bit(HIDP_WAITING_FOR_RETURN, &session->flags);
354 data[0] = report_number;
355 if (hidp_send_ctrl_message(hid->driver_data, report_type, data, 1))
358 /* Wait for the return of the report. The returned report
359 gets put in session->report_return. */
360 while (test_bit(HIDP_WAITING_FOR_RETURN, &session->flags)) {
363 res = wait_event_interruptible_timeout(session->report_queue,
364 !test_bit(HIDP_WAITING_FOR_RETURN, &session->flags),
376 skb = session->report_return;
378 len = skb->len < count ? skb->len : count;
379 memcpy(data, skb->data, len);
382 session->report_return = NULL;
384 /* Device returned a HANDSHAKE, indicating protocol error. */
388 clear_bit(HIDP_WAITING_FOR_RETURN, &session->flags);
389 mutex_unlock(&session->report_mutex);
394 clear_bit(HIDP_WAITING_FOR_RETURN, &session->flags);
395 mutex_unlock(&session->report_mutex);
398 clear_bit(HIDP_WAITING_FOR_RETURN, &session->flags);
399 mutex_unlock(&session->report_mutex);
403 static int hidp_output_raw_report(struct hid_device *hid, unsigned char *data, size_t count,
404 unsigned char report_type)
406 struct hidp_session *session = hid->driver_data;
409 switch (report_type) {
410 case HID_FEATURE_REPORT:
411 report_type = HIDP_TRANS_SET_REPORT | HIDP_DATA_RTYPE_FEATURE;
413 case HID_OUTPUT_REPORT:
414 report_type = HIDP_TRANS_SET_REPORT | HIDP_DATA_RTYPE_OUPUT;
420 if (mutex_lock_interruptible(&session->report_mutex))
423 /* Set up our wait, and send the report request to the device. */
424 set_bit(HIDP_WAITING_FOR_SEND_ACK, &session->flags);
425 if (hidp_send_ctrl_message(hid->driver_data, report_type,
431 /* Wait for the ACK from the device. */
432 while (test_bit(HIDP_WAITING_FOR_SEND_ACK, &session->flags)) {
435 res = wait_event_interruptible_timeout(session->report_queue,
436 !test_bit(HIDP_WAITING_FOR_SEND_ACK, &session->flags),
450 if (!session->output_report_success) {
458 clear_bit(HIDP_WAITING_FOR_SEND_ACK, &session->flags);
459 mutex_unlock(&session->report_mutex);
463 static void hidp_idle_timeout(unsigned long arg)
465 struct hidp_session *session = (struct hidp_session *) arg;
467 kthread_stop(session->task);
470 static void hidp_set_timer(struct hidp_session *session)
472 if (session->idle_to > 0)
473 mod_timer(&session->timer, jiffies + HZ * session->idle_to);
476 static inline void hidp_del_timer(struct hidp_session *session)
478 if (session->idle_to > 0)
479 del_timer(&session->timer);
482 static void hidp_process_handshake(struct hidp_session *session,
485 BT_DBG("session %p param 0x%02x", session, param);
486 session->output_report_success = 0; /* default condition */
489 case HIDP_HSHK_SUCCESSFUL:
490 /* FIXME: Call into SET_ GET_ handlers here */
491 session->output_report_success = 1;
494 case HIDP_HSHK_NOT_READY:
495 case HIDP_HSHK_ERR_INVALID_REPORT_ID:
496 case HIDP_HSHK_ERR_UNSUPPORTED_REQUEST:
497 case HIDP_HSHK_ERR_INVALID_PARAMETER:
498 if (test_bit(HIDP_WAITING_FOR_RETURN, &session->flags)) {
499 clear_bit(HIDP_WAITING_FOR_RETURN, &session->flags);
500 wake_up_interruptible(&session->report_queue);
502 /* FIXME: Call into SET_ GET_ handlers here */
505 case HIDP_HSHK_ERR_UNKNOWN:
508 case HIDP_HSHK_ERR_FATAL:
509 /* Device requests a reboot, as this is the only way this error
510 * can be recovered. */
511 __hidp_send_ctrl_message(session,
512 HIDP_TRANS_HID_CONTROL | HIDP_CTRL_SOFT_RESET, NULL, 0);
516 __hidp_send_ctrl_message(session,
517 HIDP_TRANS_HANDSHAKE | HIDP_HSHK_ERR_INVALID_PARAMETER, NULL, 0);
521 /* Wake up the waiting thread. */
522 if (test_bit(HIDP_WAITING_FOR_SEND_ACK, &session->flags)) {
523 clear_bit(HIDP_WAITING_FOR_SEND_ACK, &session->flags);
524 wake_up_interruptible(&session->report_queue);
528 static void hidp_process_hid_control(struct hidp_session *session,
531 BT_DBG("session %p param 0x%02x", session, param);
533 if (param == HIDP_CTRL_VIRTUAL_CABLE_UNPLUG) {
534 /* Flush the transmit queues */
535 skb_queue_purge(&session->ctrl_transmit);
536 skb_queue_purge(&session->intr_transmit);
538 kthread_stop(session->task);
542 /* Returns true if the passed-in skb should be freed by the caller. */
543 static int hidp_process_data(struct hidp_session *session, struct sk_buff *skb,
546 int done_with_skb = 1;
547 BT_DBG("session %p skb %p len %d param 0x%02x", session, skb, skb->len, param);
550 case HIDP_DATA_RTYPE_INPUT:
551 hidp_set_timer(session);
554 hidp_input_report(session, skb);
557 hid_input_report(session->hid, HID_INPUT_REPORT, skb->data, skb->len, 0);
560 case HIDP_DATA_RTYPE_OTHER:
561 case HIDP_DATA_RTYPE_OUPUT:
562 case HIDP_DATA_RTYPE_FEATURE:
566 __hidp_send_ctrl_message(session,
567 HIDP_TRANS_HANDSHAKE | HIDP_HSHK_ERR_INVALID_PARAMETER, NULL, 0);
570 if (test_bit(HIDP_WAITING_FOR_RETURN, &session->flags) &&
571 param == session->waiting_report_type) {
572 if (session->waiting_report_number < 0 ||
573 session->waiting_report_number == skb->data[0]) {
574 /* hidp_get_raw_report() is waiting on this report. */
575 session->report_return = skb;
577 clear_bit(HIDP_WAITING_FOR_RETURN, &session->flags);
578 wake_up_interruptible(&session->report_queue);
582 return done_with_skb;
585 static void hidp_recv_ctrl_frame(struct hidp_session *session,
588 unsigned char hdr, type, param;
591 BT_DBG("session %p skb %p len %d", session, skb, skb->len);
596 type = hdr & HIDP_HEADER_TRANS_MASK;
597 param = hdr & HIDP_HEADER_PARAM_MASK;
600 case HIDP_TRANS_HANDSHAKE:
601 hidp_process_handshake(session, param);
604 case HIDP_TRANS_HID_CONTROL:
605 hidp_process_hid_control(session, param);
608 case HIDP_TRANS_DATA:
609 free_skb = hidp_process_data(session, skb, param);
613 __hidp_send_ctrl_message(session,
614 HIDP_TRANS_HANDSHAKE | HIDP_HSHK_ERR_UNSUPPORTED_REQUEST, NULL, 0);
622 static void hidp_recv_intr_frame(struct hidp_session *session,
627 BT_DBG("session %p skb %p len %d", session, skb, skb->len);
632 if (hdr == (HIDP_TRANS_DATA | HIDP_DATA_RTYPE_INPUT)) {
633 hidp_set_timer(session);
636 hidp_input_report(session, skb);
639 hid_input_report(session->hid, HID_INPUT_REPORT, skb->data, skb->len, 1);
640 BT_DBG("report len %d", skb->len);
643 BT_DBG("Unsupported protocol header 0x%02x", hdr);
649 static int hidp_send_frame(struct socket *sock, unsigned char *data, int len)
651 struct kvec iv = { data, len };
654 BT_DBG("sock %p data %p len %d", sock, data, len);
659 memset(&msg, 0, sizeof(msg));
661 return kernel_sendmsg(sock, &msg, &iv, 1, len);
664 static void hidp_process_transmit(struct hidp_session *session)
668 BT_DBG("session %p", session);
670 while ((skb = skb_dequeue(&session->ctrl_transmit))) {
671 if (hidp_send_frame(session->ctrl_sock, skb->data, skb->len) < 0) {
672 skb_queue_head(&session->ctrl_transmit, skb);
676 hidp_set_timer(session);
680 while ((skb = skb_dequeue(&session->intr_transmit))) {
681 if (hidp_send_frame(session->intr_sock, skb->data, skb->len) < 0) {
682 skb_queue_head(&session->intr_transmit, skb);
686 hidp_set_timer(session);
691 static int hidp_session(void *arg)
693 struct hidp_session *session = arg;
694 struct sock *ctrl_sk = session->ctrl_sock->sk;
695 struct sock *intr_sk = session->intr_sock->sk;
697 wait_queue_t ctrl_wait, intr_wait;
699 BT_DBG("session %p", session);
701 set_user_nice(current, -15);
703 init_waitqueue_entry(&ctrl_wait, current);
704 init_waitqueue_entry(&intr_wait, current);
705 add_wait_queue(sk_sleep(ctrl_sk), &ctrl_wait);
706 add_wait_queue(sk_sleep(intr_sk), &intr_wait);
707 session->waiting_for_startup = 0;
708 wake_up_interruptible(&session->startup_queue);
709 while (!kthread_should_stop()) {
710 set_current_state(TASK_INTERRUPTIBLE);
712 if (ctrl_sk->sk_state != BT_CONNECTED ||
713 intr_sk->sk_state != BT_CONNECTED)
716 while ((skb = skb_dequeue(&ctrl_sk->sk_receive_queue))) {
718 hidp_recv_ctrl_frame(session, skb);
721 while ((skb = skb_dequeue(&intr_sk->sk_receive_queue))) {
723 hidp_recv_intr_frame(session, skb);
726 hidp_process_transmit(session);
730 set_current_state(TASK_RUNNING);
731 remove_wait_queue(sk_sleep(intr_sk), &intr_wait);
732 remove_wait_queue(sk_sleep(ctrl_sk), &ctrl_wait);
734 down_write(&hidp_session_sem);
736 hidp_del_timer(session);
738 if (session->input) {
739 input_unregister_device(session->input);
740 session->input = NULL;
744 hid_destroy_device(session->hid);
748 /* Wakeup user-space polling for socket errors */
749 session->intr_sock->sk->sk_err = EUNATCH;
750 session->ctrl_sock->sk->sk_err = EUNATCH;
752 hidp_schedule(session);
754 fput(session->intr_sock->file);
756 wait_event_timeout(*(sk_sleep(ctrl_sk)),
757 (ctrl_sk->sk_state == BT_CLOSED), msecs_to_jiffies(500));
759 fput(session->ctrl_sock->file);
761 __hidp_unlink_session(session);
763 up_write(&hidp_session_sem);
769 static struct device *hidp_get_device(struct hidp_session *session)
771 bdaddr_t *src = &bt_sk(session->ctrl_sock->sk)->src;
772 bdaddr_t *dst = &bt_sk(session->ctrl_sock->sk)->dst;
773 struct device *device = NULL;
774 struct hci_dev *hdev;
776 hdev = hci_get_route(dst, src);
780 session->conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, dst);
782 device = &session->conn->dev;
789 static int hidp_setup_input(struct hidp_session *session,
790 struct hidp_connadd_req *req)
792 struct input_dev *input;
795 input = input_allocate_device();
799 session->input = input;
801 input_set_drvdata(input, session);
803 input->name = "Bluetooth HID Boot Protocol Device";
805 input->id.bustype = BUS_BLUETOOTH;
806 input->id.vendor = req->vendor;
807 input->id.product = req->product;
808 input->id.version = req->version;
810 if (req->subclass & 0x40) {
811 set_bit(EV_KEY, input->evbit);
812 set_bit(EV_LED, input->evbit);
813 set_bit(EV_REP, input->evbit);
815 set_bit(LED_NUML, input->ledbit);
816 set_bit(LED_CAPSL, input->ledbit);
817 set_bit(LED_SCROLLL, input->ledbit);
818 set_bit(LED_COMPOSE, input->ledbit);
819 set_bit(LED_KANA, input->ledbit);
821 for (i = 0; i < sizeof(hidp_keycode); i++)
822 set_bit(hidp_keycode[i], input->keybit);
823 clear_bit(0, input->keybit);
826 if (req->subclass & 0x80) {
827 input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL);
828 input->keybit[BIT_WORD(BTN_MOUSE)] = BIT_MASK(BTN_LEFT) |
829 BIT_MASK(BTN_RIGHT) | BIT_MASK(BTN_MIDDLE);
830 input->relbit[0] = BIT_MASK(REL_X) | BIT_MASK(REL_Y);
831 input->keybit[BIT_WORD(BTN_MOUSE)] |= BIT_MASK(BTN_SIDE) |
833 input->relbit[0] |= BIT_MASK(REL_WHEEL);
836 input->dev.parent = hidp_get_device(session);
838 input->event = hidp_input_event;
840 err = input_register_device(input);
842 hci_conn_put_device(session->conn);
849 static int hidp_open(struct hid_device *hid)
854 static void hidp_close(struct hid_device *hid)
858 static int hidp_parse(struct hid_device *hid)
860 struct hidp_session *session = hid->driver_data;
862 return hid_parse_report(session->hid, session->rd_data,
866 static int hidp_start(struct hid_device *hid)
868 struct hidp_session *session = hid->driver_data;
869 struct hid_report *report;
871 list_for_each_entry(report, &hid->report_enum[HID_INPUT_REPORT].
873 hidp_send_report(session, report);
875 list_for_each_entry(report, &hid->report_enum[HID_FEATURE_REPORT].
877 hidp_send_report(session, report);
882 static void hidp_stop(struct hid_device *hid)
884 struct hidp_session *session = hid->driver_data;
886 skb_queue_purge(&session->ctrl_transmit);
887 skb_queue_purge(&session->intr_transmit);
892 static struct hid_ll_driver hidp_hid_driver = {
898 .hidinput_input_event = hidp_hidinput_event,
901 /* This function sets up the hid device. It does not add it
902 to the HID system. That is done in hidp_add_connection(). */
903 static int hidp_setup_hid(struct hidp_session *session,
904 struct hidp_connadd_req *req)
906 struct hid_device *hid;
909 session->rd_data = kzalloc(req->rd_size, GFP_KERNEL);
910 if (!session->rd_data)
913 if (copy_from_user(session->rd_data, req->rd_data, req->rd_size)) {
917 session->rd_size = req->rd_size;
919 hid = hid_allocate_device();
927 hid->driver_data = session;
929 hid->bus = BUS_BLUETOOTH;
930 hid->vendor = req->vendor;
931 hid->product = req->product;
932 hid->version = req->version;
933 hid->country = req->country;
935 strncpy(hid->name, req->name, 128);
936 strncpy(hid->phys, batostr(&bt_sk(session->ctrl_sock->sk)->src), 64);
937 strncpy(hid->uniq, batostr(&bt_sk(session->ctrl_sock->sk)->dst), 64);
939 hid->dev.parent = hidp_get_device(session);
940 hid->ll_driver = &hidp_hid_driver;
942 hid->hid_get_raw_report = hidp_get_raw_report;
943 hid->hid_output_raw_report = hidp_output_raw_report;
948 kfree(session->rd_data);
949 session->rd_data = NULL;
954 int hidp_add_connection(struct hidp_connadd_req *req, struct socket *ctrl_sock, struct socket *intr_sock)
956 struct hidp_session *session, *s;
962 if (bacmp(&bt_sk(ctrl_sock->sk)->src, &bt_sk(intr_sock->sk)->src) ||
963 bacmp(&bt_sk(ctrl_sock->sk)->dst, &bt_sk(intr_sock->sk)->dst))
966 session = kzalloc(sizeof(struct hidp_session), GFP_KERNEL);
970 BT_DBG("rd_data %p rd_size %d", req->rd_data, req->rd_size);
972 down_write(&hidp_session_sem);
974 s = __hidp_get_session(&bt_sk(ctrl_sock->sk)->dst);
975 if (s && s->state == BT_CONNECTED) {
980 bacpy(&session->bdaddr, &bt_sk(ctrl_sock->sk)->dst);
982 session->ctrl_mtu = min_t(uint, l2cap_pi(ctrl_sock->sk)->omtu, l2cap_pi(ctrl_sock->sk)->imtu);
983 session->intr_mtu = min_t(uint, l2cap_pi(intr_sock->sk)->omtu, l2cap_pi(intr_sock->sk)->imtu);
985 BT_DBG("ctrl mtu %d intr mtu %d", session->ctrl_mtu, session->intr_mtu);
987 session->ctrl_sock = ctrl_sock;
988 session->intr_sock = intr_sock;
989 session->state = BT_CONNECTED;
991 setup_timer(&session->timer, hidp_idle_timeout, (unsigned long)session);
993 skb_queue_head_init(&session->ctrl_transmit);
994 skb_queue_head_init(&session->intr_transmit);
996 mutex_init(&session->report_mutex);
997 init_waitqueue_head(&session->report_queue);
998 init_waitqueue_head(&session->startup_queue);
999 session->waiting_for_startup = 1;
1000 session->flags = req->flags & (1 << HIDP_BLUETOOTH_VENDOR_ID);
1001 session->idle_to = req->idle_to;
1003 if (req->rd_size > 0) {
1004 err = hidp_setup_hid(session, req);
1005 if (err && err != -ENODEV)
1009 if (!session->hid) {
1010 err = hidp_setup_input(session, req);
1015 __hidp_link_session(session);
1017 hidp_set_timer(session);
1020 vendor = session->hid->vendor;
1021 product = session->hid->product;
1022 } else if (session->input) {
1023 vendor = session->input->id.vendor;
1024 product = session->input->id.product;
1030 session->task = kthread_run(hidp_session, session, "khidpd_%04x%04x",
1032 if (IS_ERR(session->task)) {
1033 err = PTR_ERR(session->task);
1037 while (session->waiting_for_startup) {
1038 wait_event_interruptible(session->startup_queue,
1039 !session->waiting_for_startup);
1042 err = hid_add_device(session->hid);
1044 goto err_add_device;
1046 if (session->input) {
1047 hidp_send_ctrl_message(session,
1048 HIDP_TRANS_SET_PROTOCOL | HIDP_PROTO_BOOT, NULL, 0);
1049 session->flags |= (1 << HIDP_BOOT_PROTOCOL_MODE);
1051 session->leds = 0xff;
1052 hidp_input_event(session->input, EV_LED, 0, 0);
1055 up_write(&hidp_session_sem);
1059 hid_destroy_device(session->hid);
1060 session->hid = NULL;
1061 kthread_stop(session->task);
1064 hidp_del_timer(session);
1066 __hidp_unlink_session(session);
1068 if (session->input) {
1069 input_unregister_device(session->input);
1070 session->input = NULL;
1074 hid_destroy_device(session->hid);
1075 session->hid = NULL;
1078 kfree(session->rd_data);
1079 session->rd_data = NULL;
1082 skb_queue_purge(&session->ctrl_transmit);
1083 skb_queue_purge(&session->intr_transmit);
1086 up_write(&hidp_session_sem);
1088 input_free_device(session->input);
1093 int hidp_del_connection(struct hidp_conndel_req *req)
1095 struct hidp_session *session;
1100 down_read(&hidp_session_sem);
1102 session = __hidp_get_session(&req->bdaddr);
1104 if (req->flags & (1 << HIDP_VIRTUAL_CABLE_UNPLUG)) {
1105 hidp_send_ctrl_message(session,
1106 HIDP_TRANS_HID_CONTROL | HIDP_CTRL_VIRTUAL_CABLE_UNPLUG, NULL, 0);
1108 /* Flush the transmit queues */
1109 skb_queue_purge(&session->ctrl_transmit);
1110 skb_queue_purge(&session->intr_transmit);
1112 kthread_stop(session->task);
1117 up_read(&hidp_session_sem);
1121 int hidp_get_connlist(struct hidp_connlist_req *req)
1123 struct list_head *p;
1128 down_read(&hidp_session_sem);
1130 list_for_each(p, &hidp_session_list) {
1131 struct hidp_session *session;
1132 struct hidp_conninfo ci;
1134 session = list_entry(p, struct hidp_session, list);
1136 __hidp_copy_session(session, &ci);
1138 if (copy_to_user(req->ci, &ci, sizeof(ci))) {
1143 if (++n >= req->cnum)
1150 up_read(&hidp_session_sem);
1154 int hidp_get_conninfo(struct hidp_conninfo *ci)
1156 struct hidp_session *session;
1159 down_read(&hidp_session_sem);
1161 session = __hidp_get_session(&ci->bdaddr);
1163 __hidp_copy_session(session, ci);
1167 up_read(&hidp_session_sem);
1171 static const struct hid_device_id hidp_table[] = {
1172 { HID_BLUETOOTH_DEVICE(HID_ANY_ID, HID_ANY_ID) },
1176 static struct hid_driver hidp_driver = {
1177 .name = "generic-bluetooth",
1178 .id_table = hidp_table,
1181 static int __init hidp_init(void)
1185 BT_INFO("HIDP (Human Interface Emulation) ver %s", VERSION);
1187 ret = hid_register_driver(&hidp_driver);
1191 ret = hidp_init_sockets();
1197 hid_unregister_driver(&hidp_driver);
1202 static void __exit hidp_exit(void)
1204 hidp_cleanup_sockets();
1205 hid_unregister_driver(&hidp_driver);
1208 module_init(hidp_init);
1209 module_exit(hidp_exit);
1211 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
1212 MODULE_DESCRIPTION("Bluetooth HIDP ver " VERSION);
1213 MODULE_VERSION(VERSION);
1214 MODULE_LICENSE("GPL");
1215 MODULE_ALIAS("bt-proto-6");