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