1 /* 2 HIDP implementation for Linux Bluetooth stack (BlueZ). 3 Copyright (C) 2003-2004 Marcel Holtmann <marcel@holtmann.org> 4 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; 8 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. 17 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. 21 */ 22 23 #include <linux/module.h> 24 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/fcntl.h> 32 #include <linux/skbuff.h> 33 #include <linux/socket.h> 34 #include <linux/ioctl.h> 35 #include <linux/file.h> 36 #include <linux/init.h> 37 #include <linux/wait.h> 38 #include <net/sock.h> 39 40 #include <linux/input.h> 41 42 #include <net/bluetooth/bluetooth.h> 43 #include <net/bluetooth/l2cap.h> 44 45 #include "hidp.h" 46 47 #ifndef CONFIG_BT_HIDP_DEBUG 48 #undef BT_DBG 49 #define BT_DBG(D...) 50 #endif 51 52 #define VERSION "1.1" 53 54 static DECLARE_RWSEM(hidp_session_sem); 55 static LIST_HEAD(hidp_session_list); 56 57 static unsigned char hidp_keycode[256] = { 58 0, 0, 0, 0, 30, 48, 46, 32, 18, 33, 34, 35, 23, 36, 37, 38, 59 50, 49, 24, 25, 16, 19, 31, 20, 22, 47, 17, 45, 21, 44, 2, 3, 60 4, 5, 6, 7, 8, 9, 10, 11, 28, 1, 14, 15, 57, 12, 13, 26, 61 27, 43, 43, 39, 40, 41, 51, 52, 53, 58, 59, 60, 61, 62, 63, 64, 62 65, 66, 67, 68, 87, 88, 99, 70,119,110,102,104,111,107,109,106, 63 105,108,103, 69, 98, 55, 74, 78, 96, 79, 80, 81, 75, 76, 77, 71, 64 72, 73, 82, 83, 86,127,116,117,183,184,185,186,187,188,189,190, 65 191,192,193,194,134,138,130,132,128,129,131,137,133,135,136,113, 66 115,114, 0, 0, 0,121, 0, 89, 93,124, 92, 94, 95, 0, 0, 0, 67 122,123, 90, 91, 85, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 68 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 69 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 70 0, 0, 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, 0, 0, 72 29, 42, 56,125, 97, 54,100,126,164,166,165,163,161,115,114,113, 73 150,158,159,128,136,177,178,176,142,152,173,140 74 }; 75 76 static unsigned char hidp_mkeyspat[] = { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 }; 77 78 static struct hidp_session *__hidp_get_session(bdaddr_t *bdaddr) 79 { 80 struct hidp_session *session; 81 struct list_head *p; 82 83 BT_DBG(""); 84 85 list_for_each(p, &hidp_session_list) { 86 session = list_entry(p, struct hidp_session, list); 87 if (!bacmp(bdaddr, &session->bdaddr)) 88 return session; 89 } 90 return NULL; 91 } 92 93 static void __hidp_link_session(struct hidp_session *session) 94 { 95 __module_get(THIS_MODULE); 96 list_add(&session->list, &hidp_session_list); 97 } 98 99 static void __hidp_unlink_session(struct hidp_session *session) 100 { 101 list_del(&session->list); 102 module_put(THIS_MODULE); 103 } 104 105 static void __hidp_copy_session(struct hidp_session *session, struct hidp_conninfo *ci) 106 { 107 bacpy(&ci->bdaddr, &session->bdaddr); 108 109 ci->flags = session->flags; 110 ci->state = session->state; 111 112 ci->vendor = 0x0000; 113 ci->product = 0x0000; 114 ci->version = 0x0000; 115 memset(ci->name, 0, 128); 116 117 if (session->input) { 118 ci->vendor = session->input->id.vendor; 119 ci->product = session->input->id.product; 120 ci->version = session->input->id.version; 121 if (session->input->name) 122 strncpy(ci->name, session->input->name, 128); 123 else 124 strncpy(ci->name, "HID Boot Device", 128); 125 } 126 } 127 128 static int hidp_input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value) 129 { 130 struct hidp_session *session = dev->private; 131 struct sk_buff *skb; 132 unsigned char newleds; 133 134 BT_DBG("input %p type %d code %d value %d", dev, type, code, value); 135 136 if (type != EV_LED) 137 return -1; 138 139 newleds = (!!test_bit(LED_KANA, dev->led) << 3) | 140 (!!test_bit(LED_COMPOSE, dev->led) << 3) | 141 (!!test_bit(LED_SCROLLL, dev->led) << 2) | 142 (!!test_bit(LED_CAPSL, dev->led) << 1) | 143 (!!test_bit(LED_NUML, dev->led)); 144 145 if (session->leds == newleds) 146 return 0; 147 148 session->leds = newleds; 149 150 if (!(skb = alloc_skb(3, GFP_ATOMIC))) { 151 BT_ERR("Can't allocate memory for new frame"); 152 return -ENOMEM; 153 } 154 155 *skb_put(skb, 1) = HIDP_TRANS_DATA | HIDP_DATA_RTYPE_OUPUT; 156 *skb_put(skb, 1) = 0x01; 157 *skb_put(skb, 1) = newleds; 158 159 skb_queue_tail(&session->intr_transmit, skb); 160 161 hidp_schedule(session); 162 163 return 0; 164 } 165 166 static void hidp_input_report(struct hidp_session *session, struct sk_buff *skb) 167 { 168 struct input_dev *dev = session->input; 169 unsigned char *keys = session->keys; 170 unsigned char *udata = skb->data + 1; 171 signed char *sdata = skb->data + 1; 172 int i, size = skb->len - 1; 173 174 switch (skb->data[0]) { 175 case 0x01: /* Keyboard report */ 176 for (i = 0; i < 8; i++) 177 input_report_key(dev, hidp_keycode[i + 224], (udata[0] >> i) & 1); 178 179 /* If all the key codes have been set to 0x01, it means 180 * too many keys were pressed at the same time. */ 181 if (!memcmp(udata + 2, hidp_mkeyspat, 6)) 182 break; 183 184 for (i = 2; i < 8; i++) { 185 if (keys[i] > 3 && memscan(udata + 2, keys[i], 6) == udata + 8) { 186 if (hidp_keycode[keys[i]]) 187 input_report_key(dev, hidp_keycode[keys[i]], 0); 188 else 189 BT_ERR("Unknown key (scancode %#x) released.", keys[i]); 190 } 191 192 if (udata[i] > 3 && memscan(keys + 2, udata[i], 6) == keys + 8) { 193 if (hidp_keycode[udata[i]]) 194 input_report_key(dev, hidp_keycode[udata[i]], 1); 195 else 196 BT_ERR("Unknown key (scancode %#x) pressed.", udata[i]); 197 } 198 } 199 200 memcpy(keys, udata, 8); 201 break; 202 203 case 0x02: /* Mouse report */ 204 input_report_key(dev, BTN_LEFT, sdata[0] & 0x01); 205 input_report_key(dev, BTN_RIGHT, sdata[0] & 0x02); 206 input_report_key(dev, BTN_MIDDLE, sdata[0] & 0x04); 207 input_report_key(dev, BTN_SIDE, sdata[0] & 0x08); 208 input_report_key(dev, BTN_EXTRA, sdata[0] & 0x10); 209 210 input_report_rel(dev, REL_X, sdata[1]); 211 input_report_rel(dev, REL_Y, sdata[2]); 212 213 if (size > 3) 214 input_report_rel(dev, REL_WHEEL, sdata[3]); 215 break; 216 } 217 218 input_sync(dev); 219 } 220 221 static void hidp_idle_timeout(unsigned long arg) 222 { 223 struct hidp_session *session = (struct hidp_session *) arg; 224 225 atomic_inc(&session->terminate); 226 hidp_schedule(session); 227 } 228 229 static inline void hidp_set_timer(struct hidp_session *session) 230 { 231 if (session->idle_to > 0) 232 mod_timer(&session->timer, jiffies + HZ * session->idle_to); 233 } 234 235 static inline void hidp_del_timer(struct hidp_session *session) 236 { 237 if (session->idle_to > 0) 238 del_timer(&session->timer); 239 } 240 241 static int __hidp_send_ctrl_message(struct hidp_session *session, 242 unsigned char hdr, unsigned char *data, int size) 243 { 244 struct sk_buff *skb; 245 246 BT_DBG("session %p data %p size %d", session, data, size); 247 248 if (!(skb = alloc_skb(size + 1, GFP_ATOMIC))) { 249 BT_ERR("Can't allocate memory for new frame"); 250 return -ENOMEM; 251 } 252 253 *skb_put(skb, 1) = hdr; 254 if (data && size > 0) 255 memcpy(skb_put(skb, size), data, size); 256 257 skb_queue_tail(&session->ctrl_transmit, skb); 258 259 return 0; 260 } 261 262 static int inline hidp_send_ctrl_message(struct hidp_session *session, 263 unsigned char hdr, unsigned char *data, int size) 264 { 265 int err; 266 267 err = __hidp_send_ctrl_message(session, hdr, data, size); 268 269 hidp_schedule(session); 270 271 return err; 272 } 273 274 static inline void hidp_process_handshake(struct hidp_session *session, unsigned char param) 275 { 276 BT_DBG("session %p param 0x%02x", session, param); 277 278 switch (param) { 279 case HIDP_HSHK_SUCCESSFUL: 280 /* FIXME: Call into SET_ GET_ handlers here */ 281 break; 282 283 case HIDP_HSHK_NOT_READY: 284 case HIDP_HSHK_ERR_INVALID_REPORT_ID: 285 case HIDP_HSHK_ERR_UNSUPPORTED_REQUEST: 286 case HIDP_HSHK_ERR_INVALID_PARAMETER: 287 /* FIXME: Call into SET_ GET_ handlers here */ 288 break; 289 290 case HIDP_HSHK_ERR_UNKNOWN: 291 break; 292 293 case HIDP_HSHK_ERR_FATAL: 294 /* Device requests a reboot, as this is the only way this error 295 * can be recovered. */ 296 __hidp_send_ctrl_message(session, 297 HIDP_TRANS_HID_CONTROL | HIDP_CTRL_SOFT_RESET, NULL, 0); 298 break; 299 300 default: 301 __hidp_send_ctrl_message(session, 302 HIDP_TRANS_HANDSHAKE | HIDP_HSHK_ERR_INVALID_PARAMETER, NULL, 0); 303 break; 304 } 305 } 306 307 static inline void hidp_process_hid_control(struct hidp_session *session, unsigned char param) 308 { 309 BT_DBG("session %p param 0x%02x", session, param); 310 311 switch (param) { 312 case HIDP_CTRL_NOP: 313 break; 314 315 case HIDP_CTRL_VIRTUAL_CABLE_UNPLUG: 316 /* Flush the transmit queues */ 317 skb_queue_purge(&session->ctrl_transmit); 318 skb_queue_purge(&session->intr_transmit); 319 320 /* Kill session thread */ 321 atomic_inc(&session->terminate); 322 break; 323 324 case HIDP_CTRL_HARD_RESET: 325 case HIDP_CTRL_SOFT_RESET: 326 case HIDP_CTRL_SUSPEND: 327 case HIDP_CTRL_EXIT_SUSPEND: 328 /* FIXME: We have to parse these and return no error */ 329 break; 330 331 default: 332 __hidp_send_ctrl_message(session, 333 HIDP_TRANS_HANDSHAKE | HIDP_HSHK_ERR_INVALID_PARAMETER, NULL, 0); 334 break; 335 } 336 } 337 338 static inline void hidp_process_data(struct hidp_session *session, struct sk_buff *skb, unsigned char param) 339 { 340 BT_DBG("session %p skb %p len %d param 0x%02x", session, skb, skb->len, param); 341 342 switch (param) { 343 case HIDP_DATA_RTYPE_INPUT: 344 hidp_set_timer(session); 345 346 if (session->input) 347 hidp_input_report(session, skb); 348 break; 349 350 case HIDP_DATA_RTYPE_OTHER: 351 case HIDP_DATA_RTYPE_OUPUT: 352 case HIDP_DATA_RTYPE_FEATURE: 353 break; 354 355 default: 356 __hidp_send_ctrl_message(session, 357 HIDP_TRANS_HANDSHAKE | HIDP_HSHK_ERR_INVALID_PARAMETER, NULL, 0); 358 } 359 } 360 361 static inline void hidp_recv_ctrl_frame(struct hidp_session *session, struct sk_buff *skb) 362 { 363 unsigned char hdr, type, param; 364 365 BT_DBG("session %p skb %p len %d", session, skb, skb->len); 366 367 hdr = skb->data[0]; 368 skb_pull(skb, 1); 369 370 type = hdr & HIDP_HEADER_TRANS_MASK; 371 param = hdr & HIDP_HEADER_PARAM_MASK; 372 373 switch (type) { 374 case HIDP_TRANS_HANDSHAKE: 375 hidp_process_handshake(session, param); 376 break; 377 378 case HIDP_TRANS_HID_CONTROL: 379 hidp_process_hid_control(session, param); 380 break; 381 382 case HIDP_TRANS_DATA: 383 hidp_process_data(session, skb, param); 384 break; 385 386 default: 387 __hidp_send_ctrl_message(session, 388 HIDP_TRANS_HANDSHAKE | HIDP_HSHK_ERR_UNSUPPORTED_REQUEST, NULL, 0); 389 break; 390 } 391 392 kfree_skb(skb); 393 } 394 395 static inline void hidp_recv_intr_frame(struct hidp_session *session, struct sk_buff *skb) 396 { 397 unsigned char hdr; 398 399 BT_DBG("session %p skb %p len %d", session, skb, skb->len); 400 401 hdr = skb->data[0]; 402 skb_pull(skb, 1); 403 404 if (hdr == (HIDP_TRANS_DATA | HIDP_DATA_RTYPE_INPUT)) { 405 hidp_set_timer(session); 406 if (session->input) 407 hidp_input_report(session, skb); 408 } else { 409 BT_DBG("Unsupported protocol header 0x%02x", hdr); 410 } 411 412 kfree_skb(skb); 413 } 414 415 static int hidp_send_frame(struct socket *sock, unsigned char *data, int len) 416 { 417 struct kvec iv = { data, len }; 418 struct msghdr msg; 419 420 BT_DBG("sock %p data %p len %d", sock, data, len); 421 422 if (!len) 423 return 0; 424 425 memset(&msg, 0, sizeof(msg)); 426 427 return kernel_sendmsg(sock, &msg, &iv, 1, len); 428 } 429 430 static void hidp_process_transmit(struct hidp_session *session) 431 { 432 struct sk_buff *skb; 433 434 BT_DBG("session %p", session); 435 436 while ((skb = skb_dequeue(&session->ctrl_transmit))) { 437 if (hidp_send_frame(session->ctrl_sock, skb->data, skb->len) < 0) { 438 skb_queue_head(&session->ctrl_transmit, skb); 439 break; 440 } 441 442 hidp_set_timer(session); 443 kfree_skb(skb); 444 } 445 446 while ((skb = skb_dequeue(&session->intr_transmit))) { 447 if (hidp_send_frame(session->intr_sock, skb->data, skb->len) < 0) { 448 skb_queue_head(&session->intr_transmit, skb); 449 break; 450 } 451 452 hidp_set_timer(session); 453 kfree_skb(skb); 454 } 455 } 456 457 static int hidp_session(void *arg) 458 { 459 struct hidp_session *session = arg; 460 struct sock *ctrl_sk = session->ctrl_sock->sk; 461 struct sock *intr_sk = session->intr_sock->sk; 462 struct sk_buff *skb; 463 int vendor = 0x0000, product = 0x0000; 464 wait_queue_t ctrl_wait, intr_wait; 465 466 BT_DBG("session %p", session); 467 468 if (session->input) { 469 vendor = session->input->id.vendor; 470 product = session->input->id.product; 471 } 472 473 daemonize("khidpd_%04x%04x", vendor, product); 474 set_user_nice(current, -15); 475 current->flags |= PF_NOFREEZE; 476 477 init_waitqueue_entry(&ctrl_wait, current); 478 init_waitqueue_entry(&intr_wait, current); 479 add_wait_queue(ctrl_sk->sk_sleep, &ctrl_wait); 480 add_wait_queue(intr_sk->sk_sleep, &intr_wait); 481 while (!atomic_read(&session->terminate)) { 482 set_current_state(TASK_INTERRUPTIBLE); 483 484 if (ctrl_sk->sk_state != BT_CONNECTED || intr_sk->sk_state != BT_CONNECTED) 485 break; 486 487 while ((skb = skb_dequeue(&ctrl_sk->sk_receive_queue))) { 488 skb_orphan(skb); 489 hidp_recv_ctrl_frame(session, skb); 490 } 491 492 while ((skb = skb_dequeue(&intr_sk->sk_receive_queue))) { 493 skb_orphan(skb); 494 hidp_recv_intr_frame(session, skb); 495 } 496 497 hidp_process_transmit(session); 498 499 schedule(); 500 } 501 set_current_state(TASK_RUNNING); 502 remove_wait_queue(intr_sk->sk_sleep, &intr_wait); 503 remove_wait_queue(ctrl_sk->sk_sleep, &ctrl_wait); 504 505 down_write(&hidp_session_sem); 506 507 hidp_del_timer(session); 508 509 if (intr_sk->sk_state != BT_CONNECTED) 510 wait_event_timeout(*(ctrl_sk->sk_sleep), (ctrl_sk->sk_state == BT_CLOSED), HZ); 511 512 fput(session->ctrl_sock->file); 513 514 wait_event_timeout(*(intr_sk->sk_sleep), (intr_sk->sk_state == BT_CLOSED), HZ); 515 516 fput(session->intr_sock->file); 517 518 __hidp_unlink_session(session); 519 520 if (session->input) { 521 input_unregister_device(session->input); 522 session->input = NULL; 523 } 524 525 up_write(&hidp_session_sem); 526 527 kfree(session); 528 return 0; 529 } 530 531 static inline void hidp_setup_input(struct hidp_session *session, struct hidp_connadd_req *req) 532 { 533 struct input_dev *input = session->input; 534 int i; 535 536 input->private = session; 537 538 input->name = "Bluetooth HID Boot Protocol Device"; 539 540 input->id.bustype = BUS_BLUETOOTH; 541 input->id.vendor = req->vendor; 542 input->id.product = req->product; 543 input->id.version = req->version; 544 545 if (req->subclass & 0x40) { 546 set_bit(EV_KEY, input->evbit); 547 set_bit(EV_LED, input->evbit); 548 set_bit(EV_REP, input->evbit); 549 550 set_bit(LED_NUML, input->ledbit); 551 set_bit(LED_CAPSL, input->ledbit); 552 set_bit(LED_SCROLLL, input->ledbit); 553 set_bit(LED_COMPOSE, input->ledbit); 554 set_bit(LED_KANA, input->ledbit); 555 556 for (i = 0; i < sizeof(hidp_keycode); i++) 557 set_bit(hidp_keycode[i], input->keybit); 558 clear_bit(0, input->keybit); 559 } 560 561 if (req->subclass & 0x80) { 562 input->evbit[0] = BIT(EV_KEY) | BIT(EV_REL); 563 input->keybit[LONG(BTN_MOUSE)] = BIT(BTN_LEFT) | BIT(BTN_RIGHT) | BIT(BTN_MIDDLE); 564 input->relbit[0] = BIT(REL_X) | BIT(REL_Y); 565 input->keybit[LONG(BTN_MOUSE)] |= BIT(BTN_SIDE) | BIT(BTN_EXTRA); 566 input->relbit[0] |= BIT(REL_WHEEL); 567 } 568 569 input->event = hidp_input_event; 570 571 input_register_device(input); 572 } 573 574 int hidp_add_connection(struct hidp_connadd_req *req, struct socket *ctrl_sock, struct socket *intr_sock) 575 { 576 struct hidp_session *session, *s; 577 int err; 578 579 BT_DBG(""); 580 581 if (bacmp(&bt_sk(ctrl_sock->sk)->src, &bt_sk(intr_sock->sk)->src) || 582 bacmp(&bt_sk(ctrl_sock->sk)->dst, &bt_sk(intr_sock->sk)->dst)) 583 return -ENOTUNIQ; 584 585 session = kmalloc(sizeof(struct hidp_session), GFP_KERNEL); 586 if (!session) 587 return -ENOMEM; 588 memset(session, 0, sizeof(struct hidp_session)); 589 590 session->input = input_allocate_device(); 591 if (!session->input) { 592 kfree(session); 593 return -ENOMEM; 594 } 595 596 down_write(&hidp_session_sem); 597 598 s = __hidp_get_session(&bt_sk(ctrl_sock->sk)->dst); 599 if (s && s->state == BT_CONNECTED) { 600 err = -EEXIST; 601 goto failed; 602 } 603 604 bacpy(&session->bdaddr, &bt_sk(ctrl_sock->sk)->dst); 605 606 session->ctrl_mtu = min_t(uint, l2cap_pi(ctrl_sock->sk)->omtu, l2cap_pi(ctrl_sock->sk)->imtu); 607 session->intr_mtu = min_t(uint, l2cap_pi(intr_sock->sk)->omtu, l2cap_pi(intr_sock->sk)->imtu); 608 609 BT_DBG("ctrl mtu %d intr mtu %d", session->ctrl_mtu, session->intr_mtu); 610 611 session->ctrl_sock = ctrl_sock; 612 session->intr_sock = intr_sock; 613 session->state = BT_CONNECTED; 614 615 init_timer(&session->timer); 616 617 session->timer.function = hidp_idle_timeout; 618 session->timer.data = (unsigned long) session; 619 620 skb_queue_head_init(&session->ctrl_transmit); 621 skb_queue_head_init(&session->intr_transmit); 622 623 session->flags = req->flags & (1 << HIDP_BLUETOOTH_VENDOR_ID); 624 session->idle_to = req->idle_to; 625 626 if (session->input) 627 hidp_setup_input(session, req); 628 629 __hidp_link_session(session); 630 631 hidp_set_timer(session); 632 633 err = kernel_thread(hidp_session, session, CLONE_KERNEL); 634 if (err < 0) 635 goto unlink; 636 637 if (session->input) { 638 hidp_send_ctrl_message(session, 639 HIDP_TRANS_SET_PROTOCOL | HIDP_PROTO_BOOT, NULL, 0); 640 session->flags |= (1 << HIDP_BOOT_PROTOCOL_MODE); 641 642 session->leds = 0xff; 643 hidp_input_event(session->input, EV_LED, 0, 0); 644 } 645 646 up_write(&hidp_session_sem); 647 return 0; 648 649 unlink: 650 hidp_del_timer(session); 651 652 __hidp_unlink_session(session); 653 654 if (session->input) { 655 input_unregister_device(session->input); 656 session->input = NULL; /* don't try to free it here */ 657 } 658 659 failed: 660 up_write(&hidp_session_sem); 661 662 kfree(session->input); 663 kfree(session); 664 return err; 665 } 666 667 int hidp_del_connection(struct hidp_conndel_req *req) 668 { 669 struct hidp_session *session; 670 int err = 0; 671 672 BT_DBG(""); 673 674 down_read(&hidp_session_sem); 675 676 session = __hidp_get_session(&req->bdaddr); 677 if (session) { 678 if (req->flags & (1 << HIDP_VIRTUAL_CABLE_UNPLUG)) { 679 hidp_send_ctrl_message(session, 680 HIDP_TRANS_HID_CONTROL | HIDP_CTRL_VIRTUAL_CABLE_UNPLUG, NULL, 0); 681 } else { 682 /* Flush the transmit queues */ 683 skb_queue_purge(&session->ctrl_transmit); 684 skb_queue_purge(&session->intr_transmit); 685 686 /* Kill session thread */ 687 atomic_inc(&session->terminate); 688 hidp_schedule(session); 689 } 690 } else 691 err = -ENOENT; 692 693 up_read(&hidp_session_sem); 694 return err; 695 } 696 697 int hidp_get_connlist(struct hidp_connlist_req *req) 698 { 699 struct list_head *p; 700 int err = 0, n = 0; 701 702 BT_DBG(""); 703 704 down_read(&hidp_session_sem); 705 706 list_for_each(p, &hidp_session_list) { 707 struct hidp_session *session; 708 struct hidp_conninfo ci; 709 710 session = list_entry(p, struct hidp_session, list); 711 712 __hidp_copy_session(session, &ci); 713 714 if (copy_to_user(req->ci, &ci, sizeof(ci))) { 715 err = -EFAULT; 716 break; 717 } 718 719 if (++n >= req->cnum) 720 break; 721 722 req->ci++; 723 } 724 req->cnum = n; 725 726 up_read(&hidp_session_sem); 727 return err; 728 } 729 730 int hidp_get_conninfo(struct hidp_conninfo *ci) 731 { 732 struct hidp_session *session; 733 int err = 0; 734 735 down_read(&hidp_session_sem); 736 737 session = __hidp_get_session(&ci->bdaddr); 738 if (session) 739 __hidp_copy_session(session, ci); 740 else 741 err = -ENOENT; 742 743 up_read(&hidp_session_sem); 744 return err; 745 } 746 747 static int __init hidp_init(void) 748 { 749 l2cap_load(); 750 751 BT_INFO("HIDP (Human Interface Emulation) ver %s", VERSION); 752 753 return hidp_init_sockets(); 754 } 755 756 static void __exit hidp_exit(void) 757 { 758 hidp_cleanup_sockets(); 759 } 760 761 module_init(hidp_init); 762 module_exit(hidp_exit); 763 764 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>"); 765 MODULE_DESCRIPTION("Bluetooth HIDP ver " VERSION); 766 MODULE_VERSION(VERSION); 767 MODULE_LICENSE("GPL"); 768 MODULE_ALIAS("bt-proto-6"); 769