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/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 = kzalloc(sizeof(struct hidp_session), GFP_KERNEL);
 586         if (!session)
 587                 return -ENOMEM;
 588
 589         session->input = input_allocate_device();
 590         if (!session->input) {
 591                 kfree(session);
 592                 return -ENOMEM;
 593         }
 594
 595         down_write(&hidp_session_sem);
 596
 597         s = __hidp_get_session(&bt_sk(ctrl_sock->sk)->dst);
 598         if (s && s->state == BT_CONNECTED) {
 599                 err = -EEXIST;
 600                 goto failed;
 601         }
 602
 603         bacpy(&session->bdaddr, &bt_sk(ctrl_sock->sk)->dst);
 604
 605         session->ctrl_mtu = min_t(uint, l2cap_pi(ctrl_sock->sk)->omtu, l2cap_pi(ctrl_sock->sk)->imtu);
 606         session->intr_mtu = min_t(uint, l2cap_pi(intr_sock->sk)->omtu, l2cap_pi(intr_sock->sk)->imtu);
 607
 608         BT_DBG("ctrl mtu %d intr mtu %d", session->ctrl_mtu, session->intr_mtu);
 609
 610         session->ctrl_sock = ctrl_sock;
 611         session->intr_sock = intr_sock;
 612         session->state     = BT_CONNECTED;
 613
 614         init_timer(&session->timer);
 615
 616         session->timer.function = hidp_idle_timeout;
 617         session->timer.data     = (unsigned long) session;
 618
 619         skb_queue_head_init(&session->ctrl_transmit);
 620         skb_queue_head_init(&session->intr_transmit);
 621
 622         session->flags   = req->flags & (1 << HIDP_BLUETOOTH_VENDOR_ID);
 623         session->idle_to = req->idle_to;
 624
 625         if (session->input)
 626                 hidp_setup_input(session, req);
 627
 628         __hidp_link_session(session);
 629
 630         hidp_set_timer(session);
 631
 632         err = kernel_thread(hidp_session, session, CLONE_KERNEL);
 633         if (err < 0)
 634                 goto unlink;
 635
 636         if (session->input) {
 637                 hidp_send_ctrl_message(session,
 638                         HIDP_TRANS_SET_PROTOCOL | HIDP_PROTO_BOOT, NULL, 0);
 639                 session->flags |= (1 << HIDP_BOOT_PROTOCOL_MODE);
 640
 641                 session->leds = 0xff;
 642                 hidp_input_event(session->input, EV_LED, 0, 0);
 643         }
 644
 645         up_write(&hidp_session_sem);
 646         return 0;
 647
 648 unlink:
 649         hidp_del_timer(session);
 650
 651         __hidp_unlink_session(session);
 652
 653         if (session->input) {
 654                 input_unregister_device(session->input);
 655                 session->input = NULL; /* don't try to free it here */
 656         }
 657
 658 failed:
 659         up_write(&hidp_session_sem);
 660
 661         kfree(session->input);
 662         kfree(session);
 663         return err;
 664 }
 665
 666 int hidp_del_connection(struct hidp_conndel_req *req)
 667 {
 668         struct hidp_session *session;
 669         int err = 0;
 670
 671         BT_DBG("");
 672
 673         down_read(&hidp_session_sem);
 674
 675         session = __hidp_get_session(&req->bdaddr);
 676         if (session) {
 677                 if (req->flags & (1 << HIDP_VIRTUAL_CABLE_UNPLUG)) {
 678                         hidp_send_ctrl_message(session,
 679                                 HIDP_TRANS_HID_CONTROL | HIDP_CTRL_VIRTUAL_CABLE_UNPLUG, NULL, 0);
 680                 } else {
 681                         /* Flush the transmit queues */
 682                         skb_queue_purge(&session->ctrl_transmit);
 683                         skb_queue_purge(&session->intr_transmit);
 684
 685                         /* Kill session thread */
 686                         atomic_inc(&session->terminate);
 687                         hidp_schedule(session);
 688                 }
 689         } else
 690                 err = -ENOENT;
 691
 692         up_read(&hidp_session_sem);
 693         return err;
 694 }
 695
 696 int hidp_get_connlist(struct hidp_connlist_req *req)
 697 {
 698         struct list_head *p;
 699         int err = 0, n = 0;
 700
 701         BT_DBG("");
 702
 703         down_read(&hidp_session_sem);
 704
 705         list_for_each(p, &hidp_session_list) {
 706                 struct hidp_session *session;
 707                 struct hidp_conninfo ci;
 708
 709                 session = list_entry(p, struct hidp_session, list);
 710
 711                 __hidp_copy_session(session, &ci);
 712
 713                 if (copy_to_user(req->ci, &ci, sizeof(ci))) {
 714                         err = -EFAULT;
 715                         break;
 716                 }
 717
 718                 if (++n >= req->cnum)
 719                         break;
 720
 721                 req->ci++;
 722         }
 723         req->cnum = n;
 724
 725         up_read(&hidp_session_sem);
 726         return err;
 727 }
 728
 729 int hidp_get_conninfo(struct hidp_conninfo *ci)
 730 {
 731         struct hidp_session *session;
 732         int err = 0;
 733
 734         down_read(&hidp_session_sem);
 735
 736         session = __hidp_get_session(&ci->bdaddr);
 737         if (session)
 738                 __hidp_copy_session(session, ci);
 739         else
 740                 err = -ENOENT;
 741
 742         up_read(&hidp_session_sem);
 743         return err;
 744 }
 745
 746 static int __init hidp_init(void)
 747 {
 748         l2cap_load();
 749
 750         BT_INFO("HIDP (Human Interface Emulation) ver %s", VERSION);
 751
 752         return hidp_init_sockets();
 753 }
 754
 755 static void __exit hidp_exit(void)
 756 {
 757         hidp_cleanup_sockets();
 758 }
 759
 760 module_init(hidp_init);
 761 module_exit(hidp_exit);
 762
 763 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
 764 MODULE_DESCRIPTION("Bluetooth HIDP ver " VERSION);
 765 MODULE_VERSION(VERSION);
 766 MODULE_LICENSE("GPL");
 767 MODULE_ALIAS("bt-proto-6");