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>
24 #include <linux/file.h>
25 #include <linux/kthread.h>
26 #include <linux/hidraw.h>
28 #include <net/bluetooth/bluetooth.h>
29 #include <net/bluetooth/hci_core.h>
30 #include <net/bluetooth/l2cap.h>
36 static DECLARE_RWSEM(hidp_session_sem);
37 static LIST_HEAD(hidp_session_list);
39 static unsigned char hidp_keycode[256] = {
40 0, 0, 0, 0, 30, 48, 46, 32, 18, 33, 34, 35, 23, 36,
41 37, 38, 50, 49, 24, 25, 16, 19, 31, 20, 22, 47, 17, 45,
42 21, 44, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 28, 1,
43 14, 15, 57, 12, 13, 26, 27, 43, 43, 39, 40, 41, 51, 52,
44 53, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 87, 88,
45 99, 70, 119, 110, 102, 104, 111, 107, 109, 106, 105, 108, 103, 69,
46 98, 55, 74, 78, 96, 79, 80, 81, 75, 76, 77, 71, 72, 73,
47 82, 83, 86, 127, 116, 117, 183, 184, 185, 186, 187, 188, 189, 190,
48 191, 192, 193, 194, 134, 138, 130, 132, 128, 129, 131, 137, 133, 135,
49 136, 113, 115, 114, 0, 0, 0, 121, 0, 89, 93, 124, 92, 94,
50 95, 0, 0, 0, 122, 123, 90, 91, 85, 0, 0, 0, 0, 0,
51 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
52 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
53 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
54 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
55 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
56 29, 42, 56, 125, 97, 54, 100, 126, 164, 166, 165, 163, 161, 115,
57 114, 113, 150, 158, 159, 128, 136, 177, 178, 176, 142, 152, 173, 140
60 static unsigned char hidp_mkeyspat[] = { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 };
62 static struct hidp_session *__hidp_get_session(bdaddr_t *bdaddr)
64 struct hidp_session *session;
68 list_for_each_entry(session, &hidp_session_list, list) {
69 if (!bacmp(bdaddr, &session->bdaddr))
76 static void __hidp_link_session(struct hidp_session *session)
78 list_add(&session->list, &hidp_session_list);
81 static void __hidp_unlink_session(struct hidp_session *session)
83 hci_conn_put_device(session->conn);
85 list_del(&session->list);
88 static void __hidp_copy_session(struct hidp_session *session, struct hidp_conninfo *ci)
90 memset(ci, 0, sizeof(*ci));
91 bacpy(&ci->bdaddr, &session->bdaddr);
93 ci->flags = session->flags;
94 ci->state = session->state;
100 if (session->input) {
101 ci->vendor = session->input->id.vendor;
102 ci->product = session->input->id.product;
103 ci->version = session->input->id.version;
104 if (session->input->name)
105 strncpy(ci->name, session->input->name, 128);
107 strncpy(ci->name, "HID Boot Device", 128);
111 ci->vendor = session->hid->vendor;
112 ci->product = session->hid->product;
113 ci->version = session->hid->version;
114 strncpy(ci->name, session->hid->name, 128);
118 static int hidp_queue_event(struct hidp_session *session, struct input_dev *dev,
119 unsigned int type, unsigned int code, int value)
121 unsigned char newleds;
124 BT_DBG("session %p type %d code %d value %d", session, type, code, value);
129 newleds = (!!test_bit(LED_KANA, dev->led) << 3) |
130 (!!test_bit(LED_COMPOSE, dev->led) << 3) |
131 (!!test_bit(LED_SCROLLL, dev->led) << 2) |
132 (!!test_bit(LED_CAPSL, dev->led) << 1) |
133 (!!test_bit(LED_NUML, dev->led));
135 if (session->leds == newleds)
138 session->leds = newleds;
140 skb = alloc_skb(3, GFP_ATOMIC);
142 BT_ERR("Can't allocate memory for new frame");
146 *skb_put(skb, 1) = HIDP_TRANS_DATA | HIDP_DATA_RTYPE_OUPUT;
147 *skb_put(skb, 1) = 0x01;
148 *skb_put(skb, 1) = newleds;
150 skb_queue_tail(&session->intr_transmit, skb);
152 hidp_schedule(session);
157 static int hidp_hidinput_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
159 struct hid_device *hid = input_get_drvdata(dev);
160 struct hidp_session *session = hid->driver_data;
162 return hidp_queue_event(session, dev, type, code, value);
165 static int hidp_input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
167 struct hidp_session *session = input_get_drvdata(dev);
169 return hidp_queue_event(session, dev, type, code, value);
172 static void hidp_input_report(struct hidp_session *session, struct sk_buff *skb)
174 struct input_dev *dev = session->input;
175 unsigned char *keys = session->keys;
176 unsigned char *udata = skb->data + 1;
177 signed char *sdata = skb->data + 1;
178 int i, size = skb->len - 1;
180 switch (skb->data[0]) {
181 case 0x01: /* Keyboard report */
182 for (i = 0; i < 8; i++)
183 input_report_key(dev, hidp_keycode[i + 224], (udata[0] >> i) & 1);
185 /* If all the key codes have been set to 0x01, it means
186 * too many keys were pressed at the same time. */
187 if (!memcmp(udata + 2, hidp_mkeyspat, 6))
190 for (i = 2; i < 8; i++) {
191 if (keys[i] > 3 && memscan(udata + 2, keys[i], 6) == udata + 8) {
192 if (hidp_keycode[keys[i]])
193 input_report_key(dev, hidp_keycode[keys[i]], 0);
195 BT_ERR("Unknown key (scancode %#x) released.", keys[i]);
198 if (udata[i] > 3 && memscan(keys + 2, udata[i], 6) == keys + 8) {
199 if (hidp_keycode[udata[i]])
200 input_report_key(dev, hidp_keycode[udata[i]], 1);
202 BT_ERR("Unknown key (scancode %#x) pressed.", udata[i]);
206 memcpy(keys, udata, 8);
209 case 0x02: /* Mouse report */
210 input_report_key(dev, BTN_LEFT, sdata[0] & 0x01);
211 input_report_key(dev, BTN_RIGHT, sdata[0] & 0x02);
212 input_report_key(dev, BTN_MIDDLE, sdata[0] & 0x04);
213 input_report_key(dev, BTN_SIDE, sdata[0] & 0x08);
214 input_report_key(dev, BTN_EXTRA, sdata[0] & 0x10);
216 input_report_rel(dev, REL_X, sdata[1]);
217 input_report_rel(dev, REL_Y, sdata[2]);
220 input_report_rel(dev, REL_WHEEL, sdata[3]);
227 static int __hidp_send_ctrl_message(struct hidp_session *session,
228 unsigned char hdr, unsigned char *data,
233 BT_DBG("session %p data %p size %d", session, data, size);
235 if (atomic_read(&session->terminate))
238 skb = alloc_skb(size + 1, GFP_ATOMIC);
240 BT_ERR("Can't allocate memory for new frame");
244 *skb_put(skb, 1) = hdr;
245 if (data && size > 0)
246 memcpy(skb_put(skb, size), data, size);
248 skb_queue_tail(&session->ctrl_transmit, skb);
253 static int hidp_send_ctrl_message(struct hidp_session *session,
254 unsigned char hdr, unsigned char *data, int size)
258 err = __hidp_send_ctrl_message(session, hdr, data, size);
260 hidp_schedule(session);
265 static int hidp_queue_report(struct hidp_session *session,
266 unsigned char *data, int size)
270 BT_DBG("session %p hid %p data %p size %d", session, session->hid, data, size);
272 skb = alloc_skb(size + 1, GFP_ATOMIC);
274 BT_ERR("Can't allocate memory for new frame");
278 *skb_put(skb, 1) = 0xa2;
280 memcpy(skb_put(skb, size), data, size);
282 skb_queue_tail(&session->intr_transmit, skb);
284 hidp_schedule(session);
289 static int hidp_send_report(struct hidp_session *session, struct hid_report *report)
291 unsigned char buf[32];
294 rsize = ((report->size - 1) >> 3) + 1 + (report->id > 0);
295 if (rsize > sizeof(buf))
298 hid_output_report(report, buf);
300 return hidp_queue_report(session, buf, rsize);
303 static int hidp_get_raw_report(struct hid_device *hid,
304 unsigned char report_number,
305 unsigned char *data, size_t count,
306 unsigned char report_type)
308 struct hidp_session *session = hid->driver_data;
311 int numbered_reports = hid->report_enum[report_type].numbered;
314 switch (report_type) {
315 case HID_FEATURE_REPORT:
316 report_type = HIDP_TRANS_GET_REPORT | HIDP_DATA_RTYPE_FEATURE;
318 case HID_INPUT_REPORT:
319 report_type = HIDP_TRANS_GET_REPORT | HIDP_DATA_RTYPE_INPUT;
321 case HID_OUTPUT_REPORT:
322 report_type = HIDP_TRANS_GET_REPORT | HIDP_DATA_RTYPE_OUPUT;
328 if (mutex_lock_interruptible(&session->report_mutex))
331 /* Set up our wait, and send the report request to the device. */
332 session->waiting_report_type = report_type & HIDP_DATA_RTYPE_MASK;
333 session->waiting_report_number = numbered_reports ? report_number : -1;
334 set_bit(HIDP_WAITING_FOR_RETURN, &session->flags);
335 data[0] = report_number;
336 ret = hidp_send_ctrl_message(hid->driver_data, report_type, data, 1);
340 /* Wait for the return of the report. The returned report
341 gets put in session->report_return. */
342 while (test_bit(HIDP_WAITING_FOR_RETURN, &session->flags)) {
345 res = wait_event_interruptible_timeout(session->report_queue,
346 !test_bit(HIDP_WAITING_FOR_RETURN, &session->flags),
360 skb = session->report_return;
362 len = skb->len < count ? skb->len : count;
363 memcpy(data, skb->data, len);
366 session->report_return = NULL;
368 /* Device returned a HANDSHAKE, indicating protocol error. */
372 clear_bit(HIDP_WAITING_FOR_RETURN, &session->flags);
373 mutex_unlock(&session->report_mutex);
378 clear_bit(HIDP_WAITING_FOR_RETURN, &session->flags);
379 mutex_unlock(&session->report_mutex);
383 static int hidp_output_raw_report(struct hid_device *hid, unsigned char *data, size_t count,
384 unsigned char report_type)
386 struct hidp_session *session = hid->driver_data;
389 switch (report_type) {
390 case HID_FEATURE_REPORT:
391 report_type = HIDP_TRANS_SET_REPORT | HIDP_DATA_RTYPE_FEATURE;
393 case HID_OUTPUT_REPORT:
394 report_type = HIDP_TRANS_SET_REPORT | HIDP_DATA_RTYPE_OUPUT;
400 if (mutex_lock_interruptible(&session->report_mutex))
403 /* Set up our wait, and send the report request to the device. */
404 set_bit(HIDP_WAITING_FOR_SEND_ACK, &session->flags);
405 ret = hidp_send_ctrl_message(hid->driver_data, report_type, data,
410 /* Wait for the ACK from the device. */
411 while (test_bit(HIDP_WAITING_FOR_SEND_ACK, &session->flags)) {
414 res = wait_event_interruptible_timeout(session->report_queue,
415 !test_bit(HIDP_WAITING_FOR_SEND_ACK, &session->flags),
429 if (!session->output_report_success) {
437 clear_bit(HIDP_WAITING_FOR_SEND_ACK, &session->flags);
438 mutex_unlock(&session->report_mutex);
442 static void hidp_idle_timeout(unsigned long arg)
444 struct hidp_session *session = (struct hidp_session *) arg;
446 atomic_inc(&session->terminate);
447 wake_up_process(session->task);
450 static void hidp_set_timer(struct hidp_session *session)
452 if (session->idle_to > 0)
453 mod_timer(&session->timer, jiffies + HZ * session->idle_to);
456 static void hidp_del_timer(struct hidp_session *session)
458 if (session->idle_to > 0)
459 del_timer(&session->timer);
462 static void hidp_process_handshake(struct hidp_session *session,
465 BT_DBG("session %p param 0x%02x", session, param);
466 session->output_report_success = 0; /* default condition */
469 case HIDP_HSHK_SUCCESSFUL:
470 /* FIXME: Call into SET_ GET_ handlers here */
471 session->output_report_success = 1;
474 case HIDP_HSHK_NOT_READY:
475 case HIDP_HSHK_ERR_INVALID_REPORT_ID:
476 case HIDP_HSHK_ERR_UNSUPPORTED_REQUEST:
477 case HIDP_HSHK_ERR_INVALID_PARAMETER:
478 if (test_and_clear_bit(HIDP_WAITING_FOR_RETURN, &session->flags))
479 wake_up_interruptible(&session->report_queue);
481 /* FIXME: Call into SET_ GET_ handlers here */
484 case HIDP_HSHK_ERR_UNKNOWN:
487 case HIDP_HSHK_ERR_FATAL:
488 /* Device requests a reboot, as this is the only way this error
489 * can be recovered. */
490 __hidp_send_ctrl_message(session,
491 HIDP_TRANS_HID_CONTROL | HIDP_CTRL_SOFT_RESET, NULL, 0);
495 __hidp_send_ctrl_message(session,
496 HIDP_TRANS_HANDSHAKE | HIDP_HSHK_ERR_INVALID_PARAMETER, NULL, 0);
500 /* Wake up the waiting thread. */
501 if (test_and_clear_bit(HIDP_WAITING_FOR_SEND_ACK, &session->flags))
502 wake_up_interruptible(&session->report_queue);
505 static void hidp_process_hid_control(struct hidp_session *session,
508 BT_DBG("session %p param 0x%02x", session, param);
510 if (param == HIDP_CTRL_VIRTUAL_CABLE_UNPLUG) {
511 /* Flush the transmit queues */
512 skb_queue_purge(&session->ctrl_transmit);
513 skb_queue_purge(&session->intr_transmit);
515 atomic_inc(&session->terminate);
516 wake_up_process(current);
520 /* Returns true if the passed-in skb should be freed by the caller. */
521 static int hidp_process_data(struct hidp_session *session, struct sk_buff *skb,
524 int done_with_skb = 1;
525 BT_DBG("session %p skb %p len %d param 0x%02x", session, skb, skb->len, param);
528 case HIDP_DATA_RTYPE_INPUT:
529 hidp_set_timer(session);
532 hidp_input_report(session, skb);
535 hid_input_report(session->hid, HID_INPUT_REPORT, skb->data, skb->len, 0);
538 case HIDP_DATA_RTYPE_OTHER:
539 case HIDP_DATA_RTYPE_OUPUT:
540 case HIDP_DATA_RTYPE_FEATURE:
544 __hidp_send_ctrl_message(session,
545 HIDP_TRANS_HANDSHAKE | HIDP_HSHK_ERR_INVALID_PARAMETER, NULL, 0);
548 if (test_bit(HIDP_WAITING_FOR_RETURN, &session->flags) &&
549 param == session->waiting_report_type) {
550 if (session->waiting_report_number < 0 ||
551 session->waiting_report_number == skb->data[0]) {
552 /* hidp_get_raw_report() is waiting on this report. */
553 session->report_return = skb;
555 clear_bit(HIDP_WAITING_FOR_RETURN, &session->flags);
556 wake_up_interruptible(&session->report_queue);
560 return done_with_skb;
563 static void hidp_recv_ctrl_frame(struct hidp_session *session,
566 unsigned char hdr, type, param;
569 BT_DBG("session %p skb %p len %d", session, skb, skb->len);
574 type = hdr & HIDP_HEADER_TRANS_MASK;
575 param = hdr & HIDP_HEADER_PARAM_MASK;
578 case HIDP_TRANS_HANDSHAKE:
579 hidp_process_handshake(session, param);
582 case HIDP_TRANS_HID_CONTROL:
583 hidp_process_hid_control(session, param);
586 case HIDP_TRANS_DATA:
587 free_skb = hidp_process_data(session, skb, param);
591 __hidp_send_ctrl_message(session,
592 HIDP_TRANS_HANDSHAKE | HIDP_HSHK_ERR_UNSUPPORTED_REQUEST, NULL, 0);
600 static void hidp_recv_intr_frame(struct hidp_session *session,
605 BT_DBG("session %p skb %p len %d", session, skb, skb->len);
610 if (hdr == (HIDP_TRANS_DATA | HIDP_DATA_RTYPE_INPUT)) {
611 hidp_set_timer(session);
614 hidp_input_report(session, skb);
617 hid_input_report(session->hid, HID_INPUT_REPORT, skb->data, skb->len, 1);
618 BT_DBG("report len %d", skb->len);
621 BT_DBG("Unsupported protocol header 0x%02x", hdr);
627 static int hidp_send_frame(struct socket *sock, unsigned char *data, int len)
629 struct kvec iv = { data, len };
632 BT_DBG("sock %p data %p len %d", sock, data, len);
637 memset(&msg, 0, sizeof(msg));
639 return kernel_sendmsg(sock, &msg, &iv, 1, len);
642 static void hidp_process_intr_transmit(struct hidp_session *session)
646 BT_DBG("session %p", session);
648 while ((skb = skb_dequeue(&session->intr_transmit))) {
649 if (hidp_send_frame(session->intr_sock, skb->data, skb->len) < 0) {
650 skb_queue_head(&session->intr_transmit, skb);
654 hidp_set_timer(session);
659 static void hidp_process_ctrl_transmit(struct hidp_session *session)
663 BT_DBG("session %p", session);
665 while ((skb = skb_dequeue(&session->ctrl_transmit))) {
666 if (hidp_send_frame(session->ctrl_sock, skb->data, skb->len) < 0) {
667 skb_queue_head(&session->ctrl_transmit, skb);
671 hidp_set_timer(session);
676 static int hidp_session(void *arg)
678 struct hidp_session *session = arg;
679 struct sock *ctrl_sk = session->ctrl_sock->sk;
680 struct sock *intr_sk = session->intr_sock->sk;
682 wait_queue_t ctrl_wait, intr_wait;
684 BT_DBG("session %p", session);
686 __module_get(THIS_MODULE);
687 set_user_nice(current, -15);
689 init_waitqueue_entry(&ctrl_wait, current);
690 init_waitqueue_entry(&intr_wait, current);
691 add_wait_queue(sk_sleep(ctrl_sk), &ctrl_wait);
692 add_wait_queue(sk_sleep(intr_sk), &intr_wait);
693 session->waiting_for_startup = 0;
694 wake_up_interruptible(&session->startup_queue);
695 set_current_state(TASK_INTERRUPTIBLE);
696 while (!atomic_read(&session->terminate)) {
697 if (ctrl_sk->sk_state != BT_CONNECTED ||
698 intr_sk->sk_state != BT_CONNECTED)
701 while ((skb = skb_dequeue(&intr_sk->sk_receive_queue))) {
703 if (!skb_linearize(skb))
704 hidp_recv_intr_frame(session, skb);
709 hidp_process_intr_transmit(session);
711 while ((skb = skb_dequeue(&ctrl_sk->sk_receive_queue))) {
713 if (!skb_linearize(skb))
714 hidp_recv_ctrl_frame(session, skb);
719 hidp_process_ctrl_transmit(session);
722 set_current_state(TASK_INTERRUPTIBLE);
724 set_current_state(TASK_RUNNING);
725 remove_wait_queue(sk_sleep(intr_sk), &intr_wait);
726 remove_wait_queue(sk_sleep(ctrl_sk), &ctrl_wait);
728 clear_bit(HIDP_WAITING_FOR_SEND_ACK, &session->flags);
729 clear_bit(HIDP_WAITING_FOR_RETURN, &session->flags);
730 wake_up_interruptible(&session->report_queue);
732 down_write(&hidp_session_sem);
734 hidp_del_timer(session);
736 if (session->input) {
737 input_unregister_device(session->input);
738 session->input = NULL;
742 hid_destroy_device(session->hid);
746 /* Wakeup user-space polling for socket errors */
747 session->intr_sock->sk->sk_err = EUNATCH;
748 session->ctrl_sock->sk->sk_err = EUNATCH;
750 hidp_schedule(session);
752 fput(session->intr_sock->file);
754 wait_event_timeout(*(sk_sleep(ctrl_sk)),
755 (ctrl_sk->sk_state == BT_CLOSED), msecs_to_jiffies(500));
757 fput(session->ctrl_sock->file);
759 __hidp_unlink_session(session);
761 up_write(&hidp_session_sem);
763 kfree(session->rd_data);
765 module_put_and_exit(0);
769 static struct hci_conn *hidp_get_connection(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 hci_conn *conn;
774 struct hci_dev *hdev;
776 hdev = hci_get_route(dst, src);
781 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, dst);
783 hci_conn_hold_device(conn);
784 hci_dev_unlock(hdev);
791 static int hidp_setup_input(struct hidp_session *session,
792 struct hidp_connadd_req *req)
794 struct input_dev *input;
797 input = input_allocate_device();
801 session->input = input;
803 input_set_drvdata(input, session);
805 input->name = "Bluetooth HID Boot Protocol Device";
807 input->id.bustype = BUS_BLUETOOTH;
808 input->id.vendor = req->vendor;
809 input->id.product = req->product;
810 input->id.version = req->version;
812 if (req->subclass & 0x40) {
813 set_bit(EV_KEY, input->evbit);
814 set_bit(EV_LED, input->evbit);
815 set_bit(EV_REP, input->evbit);
817 set_bit(LED_NUML, input->ledbit);
818 set_bit(LED_CAPSL, input->ledbit);
819 set_bit(LED_SCROLLL, input->ledbit);
820 set_bit(LED_COMPOSE, input->ledbit);
821 set_bit(LED_KANA, input->ledbit);
823 for (i = 0; i < sizeof(hidp_keycode); i++)
824 set_bit(hidp_keycode[i], input->keybit);
825 clear_bit(0, input->keybit);
828 if (req->subclass & 0x80) {
829 input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL);
830 input->keybit[BIT_WORD(BTN_MOUSE)] = BIT_MASK(BTN_LEFT) |
831 BIT_MASK(BTN_RIGHT) | BIT_MASK(BTN_MIDDLE);
832 input->relbit[0] = BIT_MASK(REL_X) | BIT_MASK(REL_Y);
833 input->keybit[BIT_WORD(BTN_MOUSE)] |= BIT_MASK(BTN_SIDE) |
835 input->relbit[0] |= BIT_MASK(REL_WHEEL);
838 input->dev.parent = &session->conn->dev;
840 input->event = hidp_input_event;
845 static int hidp_open(struct hid_device *hid)
850 static void hidp_close(struct hid_device *hid)
854 static int hidp_parse(struct hid_device *hid)
856 struct hidp_session *session = hid->driver_data;
858 return hid_parse_report(session->hid, session->rd_data,
862 static int hidp_start(struct hid_device *hid)
864 struct hidp_session *session = hid->driver_data;
865 struct hid_report *report;
867 if (hid->quirks & HID_QUIRK_NO_INIT_REPORTS)
870 list_for_each_entry(report, &hid->report_enum[HID_INPUT_REPORT].
872 hidp_send_report(session, report);
874 list_for_each_entry(report, &hid->report_enum[HID_FEATURE_REPORT].
876 hidp_send_report(session, report);
881 static void hidp_stop(struct hid_device *hid)
883 struct hidp_session *session = hid->driver_data;
885 skb_queue_purge(&session->ctrl_transmit);
886 skb_queue_purge(&session->intr_transmit);
891 static struct hid_ll_driver hidp_hid_driver = {
897 .hidinput_input_event = hidp_hidinput_event,
900 /* This function sets up the hid device. It does not add it
901 to the HID system. That is done in hidp_add_connection(). */
902 static int hidp_setup_hid(struct hidp_session *session,
903 struct hidp_connadd_req *req)
905 struct hid_device *hid;
908 session->rd_data = kzalloc(req->rd_size, GFP_KERNEL);
909 if (!session->rd_data)
912 if (copy_from_user(session->rd_data, req->rd_data, req->rd_size)) {
916 session->rd_size = req->rd_size;
918 hid = hid_allocate_device();
926 hid->driver_data = session;
928 hid->bus = BUS_BLUETOOTH;
929 hid->vendor = req->vendor;
930 hid->product = req->product;
931 hid->version = req->version;
932 hid->country = req->country;
934 strncpy(hid->name, req->name, sizeof(req->name) - 1);
936 snprintf(hid->phys, sizeof(hid->phys), "%pMR",
937 &bt_sk(session->ctrl_sock->sk)->src);
939 snprintf(hid->uniq, sizeof(hid->uniq), "%pMR",
940 &bt_sk(session->ctrl_sock->sk)->dst);
942 hid->dev.parent = &session->conn->dev;
943 hid->ll_driver = &hidp_hid_driver;
945 hid->hid_get_raw_report = hidp_get_raw_report;
946 hid->hid_output_raw_report = hidp_output_raw_report;
948 /* True if device is blacklisted in drivers/hid/hid-core.c */
949 if (hid_ignore(hid)) {
950 hid_destroy_device(session->hid);
958 kfree(session->rd_data);
959 session->rd_data = NULL;
964 int hidp_add_connection(struct hidp_connadd_req *req, struct socket *ctrl_sock, struct socket *intr_sock)
966 struct hidp_session *session, *s;
972 if (bacmp(&bt_sk(ctrl_sock->sk)->src, &bt_sk(intr_sock->sk)->src) ||
973 bacmp(&bt_sk(ctrl_sock->sk)->dst, &bt_sk(intr_sock->sk)->dst))
976 BT_DBG("rd_data %p rd_size %d", req->rd_data, req->rd_size);
978 down_write(&hidp_session_sem);
980 s = __hidp_get_session(&bt_sk(ctrl_sock->sk)->dst);
981 if (s && s->state == BT_CONNECTED) {
982 up_write(&hidp_session_sem);
986 session = kzalloc(sizeof(struct hidp_session), GFP_KERNEL);
988 up_write(&hidp_session_sem);
992 bacpy(&session->bdaddr, &bt_sk(ctrl_sock->sk)->dst);
994 session->ctrl_mtu = min_t(uint, l2cap_pi(ctrl_sock->sk)->chan->omtu,
995 l2cap_pi(ctrl_sock->sk)->chan->imtu);
996 session->intr_mtu = min_t(uint, l2cap_pi(intr_sock->sk)->chan->omtu,
997 l2cap_pi(intr_sock->sk)->chan->imtu);
999 BT_DBG("ctrl mtu %d intr mtu %d", session->ctrl_mtu, session->intr_mtu);
1001 session->ctrl_sock = ctrl_sock;
1002 session->intr_sock = intr_sock;
1003 session->state = BT_CONNECTED;
1005 session->conn = hidp_get_connection(session);
1006 if (!session->conn) {
1011 setup_timer(&session->timer, hidp_idle_timeout, (unsigned long)session);
1013 skb_queue_head_init(&session->ctrl_transmit);
1014 skb_queue_head_init(&session->intr_transmit);
1016 mutex_init(&session->report_mutex);
1017 init_waitqueue_head(&session->report_queue);
1018 init_waitqueue_head(&session->startup_queue);
1019 session->waiting_for_startup = 1;
1020 session->flags = req->flags & (1 << HIDP_BLUETOOTH_VENDOR_ID);
1021 session->idle_to = req->idle_to;
1023 __hidp_link_session(session);
1025 if (req->rd_size > 0) {
1026 err = hidp_setup_hid(session, req);
1027 if (err && err != -ENODEV)
1031 if (!session->hid) {
1032 err = hidp_setup_input(session, req);
1037 hidp_set_timer(session);
1040 vendor = session->hid->vendor;
1041 product = session->hid->product;
1042 } else if (session->input) {
1043 vendor = session->input->id.vendor;
1044 product = session->input->id.product;
1050 session->task = kthread_run(hidp_session, session, "khidpd_%04x%04x",
1052 if (IS_ERR(session->task)) {
1053 err = PTR_ERR(session->task);
1057 while (session->waiting_for_startup) {
1058 wait_event_interruptible(session->startup_queue,
1059 !session->waiting_for_startup);
1063 err = hid_add_device(session->hid);
1065 err = input_register_device(session->input);
1068 atomic_inc(&session->terminate);
1069 wake_up_process(session->task);
1070 up_write(&hidp_session_sem);
1074 if (session->input) {
1075 hidp_send_ctrl_message(session,
1076 HIDP_TRANS_SET_PROTOCOL | HIDP_PROTO_BOOT, NULL, 0);
1077 session->flags |= (1 << HIDP_BOOT_PROTOCOL_MODE);
1079 session->leds = 0xff;
1080 hidp_input_event(session->input, EV_LED, 0, 0);
1083 up_write(&hidp_session_sem);
1087 hidp_del_timer(session);
1089 if (session->input) {
1090 input_unregister_device(session->input);
1091 session->input = NULL;
1095 hid_destroy_device(session->hid);
1096 session->hid = NULL;
1099 kfree(session->rd_data);
1100 session->rd_data = NULL;
1103 __hidp_unlink_session(session);
1105 skb_queue_purge(&session->ctrl_transmit);
1106 skb_queue_purge(&session->intr_transmit);
1109 up_write(&hidp_session_sem);
1115 int hidp_del_connection(struct hidp_conndel_req *req)
1117 struct hidp_session *session;
1122 down_read(&hidp_session_sem);
1124 session = __hidp_get_session(&req->bdaddr);
1126 if (req->flags & (1 << HIDP_VIRTUAL_CABLE_UNPLUG)) {
1127 hidp_send_ctrl_message(session,
1128 HIDP_TRANS_HID_CONTROL | HIDP_CTRL_VIRTUAL_CABLE_UNPLUG, NULL, 0);
1130 /* Flush the transmit queues */
1131 skb_queue_purge(&session->ctrl_transmit);
1132 skb_queue_purge(&session->intr_transmit);
1134 atomic_inc(&session->terminate);
1135 wake_up_process(session->task);
1140 up_read(&hidp_session_sem);
1144 int hidp_get_connlist(struct hidp_connlist_req *req)
1146 struct hidp_session *session;
1151 down_read(&hidp_session_sem);
1153 list_for_each_entry(session, &hidp_session_list, list) {
1154 struct hidp_conninfo ci;
1156 __hidp_copy_session(session, &ci);
1158 if (copy_to_user(req->ci, &ci, sizeof(ci))) {
1163 if (++n >= req->cnum)
1170 up_read(&hidp_session_sem);
1174 int hidp_get_conninfo(struct hidp_conninfo *ci)
1176 struct hidp_session *session;
1179 down_read(&hidp_session_sem);
1181 session = __hidp_get_session(&ci->bdaddr);
1183 __hidp_copy_session(session, ci);
1187 up_read(&hidp_session_sem);
1191 static int __init hidp_init(void)
1193 BT_INFO("HIDP (Human Interface Emulation) ver %s", VERSION);
1195 return hidp_init_sockets();
1198 static void __exit hidp_exit(void)
1200 hidp_cleanup_sockets();
1203 module_init(hidp_init);
1204 module_exit(hidp_exit);
1206 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
1207 MODULE_DESCRIPTION("Bluetooth HIDP ver " VERSION);
1208 MODULE_VERSION(VERSION);
1209 MODULE_LICENSE("GPL");
1210 MODULE_ALIAS("bt-proto-6");