net/bluetooth/hidp/core.c

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