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    Copyright (C) 2013 David Herrmann <dh.herrmann@gmail.com>
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License version 2 as
   8    published by the Free Software Foundation;
   9
  10    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  11    OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  12    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
  13    IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
  14    CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
  15    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  16    ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  17    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  18
  19    ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
  20    COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
  21    SOFTWARE IS DISCLAIMED.
  22 */
  23
  24 #include <linux/kref.h>
  25 #include <linux/module.h>
  26 #include <linux/file.h>
  27 #include <linux/kthread.h>
  28 #include <linux/hidraw.h>
  29
  30 #include <net/bluetooth/bluetooth.h>
  31 #include <net/bluetooth/hci_core.h>
  32 #include <net/bluetooth/l2cap.h>
  33
  34 #include "hidp.h"
  35
  36 #define VERSION "1.2"
  37
  38 static DECLARE_RWSEM(hidp_session_sem);
  39 static LIST_HEAD(hidp_session_list);
  40
  41 static unsigned char hidp_keycode[256] = {
  42           0,   0,   0,   0,  30,  48,  46,  32,  18,  33,  34,  35,  23,  36,
  43          37,  38,  50,  49,  24,  25,  16,  19,  31,  20,  22,  47,  17,  45,
  44          21,  44,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  28,   1,
  45          14,  15,  57,  12,  13,  26,  27,  43,  43,  39,  40,  41,  51,  52,
  46          53,  58,  59,  60,  61,  62,  63,  64,  65,  66,  67,  68,  87,  88,
  47          99,  70, 119, 110, 102, 104, 111, 107, 109, 106, 105, 108, 103,  69,
  48          98,  55,  74,  78,  96,  79,  80,  81,  75,  76,  77,  71,  72,  73,
  49          82,  83,  86, 127, 116, 117, 183, 184, 185, 186, 187, 188, 189, 190,
  50         191, 192, 193, 194, 134, 138, 130, 132, 128, 129, 131, 137, 133, 135,
  51         136, 113, 115, 114,   0,   0,   0, 121,   0,  89,  93, 124,  92,  94,
  52          95,   0,   0,   0, 122, 123,  90,  91,  85,   0,   0,   0,   0,   0,
  53           0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  54           0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  55           0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  56           0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  57           0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  58          29,  42,  56, 125,  97,  54, 100, 126, 164, 166, 165, 163, 161, 115,
  59         114, 113, 150, 158, 159, 128, 136, 177, 178, 176, 142, 152, 173, 140
  60 };
  61
  62 static unsigned char hidp_mkeyspat[] = { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 };
  63
  64 static int hidp_session_probe(struct l2cap_conn *conn,
  65                               struct l2cap_user *user);
  66 static void hidp_session_remove(struct l2cap_conn *conn,
  67                                 struct l2cap_user *user);
  68 static int hidp_session_thread(void *arg);
  69 static void hidp_session_terminate(struct hidp_session *s);
  70
  71 static void hidp_copy_session(struct hidp_session *session, struct hidp_conninfo *ci)
  72 {
  73         memset(ci, 0, sizeof(*ci));
  74         bacpy(&ci->bdaddr, &session->bdaddr);
  75
  76         ci->flags = session->flags;
  77         ci->state = BT_CONNECTED;
  78
  79         if (session->input) {
  80                 ci->vendor  = session->input->id.vendor;
  81                 ci->product = session->input->id.product;
  82                 ci->version = session->input->id.version;
  83                 if (session->input->name)
  84                         strlcpy(ci->name, session->input->name, 128);
  85                 else
  86                         strlcpy(ci->name, "HID Boot Device", 128);
  87         } else if (session->hid) {
  88                 ci->vendor  = session->hid->vendor;
  89                 ci->product = session->hid->product;
  90                 ci->version = session->hid->version;
  91                 strlcpy(ci->name, session->hid->name, 128);
  92         }
  93 }
  94
  95 /* assemble skb, queue message on @transmit and wake up the session thread */
  96 static int hidp_send_message(struct hidp_session *session, struct socket *sock,
  97                              struct sk_buff_head *transmit, unsigned char hdr,
  98                              const unsigned char *data, int size)
  99 {
 100         struct sk_buff *skb;
 101         struct sock *sk = sock->sk;
 102
 103         BT_DBG("session %p data %p size %d", session, data, size);
 104
 105         if (atomic_read(&session->terminate))
 106                 return -EIO;
 107
 108         skb = alloc_skb(size + 1, GFP_ATOMIC);
 109         if (!skb) {
 110                 BT_ERR("Can't allocate memory for new frame");
 111                 return -ENOMEM;
 112         }
 113
 114         *skb_put(skb, 1) = hdr;
 115         if (data && size > 0)
 116                 memcpy(skb_put(skb, size), data, size);
 117
 118         skb_queue_tail(transmit, skb);
 119         wake_up_interruptible(sk_sleep(sk));
 120
 121         return 0;
 122 }
 123
 124 static int hidp_send_ctrl_message(struct hidp_session *session,
 125                                   unsigned char hdr, const unsigned char *data,
 126                                   int size)
 127 {
 128         return hidp_send_message(session, session->ctrl_sock,
 129                                  &session->ctrl_transmit, hdr, data, size);
 130 }
 131
 132 static int hidp_send_intr_message(struct hidp_session *session,
 133                                   unsigned char hdr, const unsigned char *data,
 134                                   int size)
 135 {
 136         return hidp_send_message(session, session->intr_sock,
 137                                  &session->intr_transmit, hdr, data, size);
 138 }
 139
 140 static int hidp_input_event(struct input_dev *dev, unsigned int type,
 141                             unsigned int code, int value)
 142 {
 143         struct hidp_session *session = input_get_drvdata(dev);
 144         unsigned char newleds;
 145         unsigned char hdr, data[2];
 146
 147         BT_DBG("session %p type %d code %d value %d",
 148                session, type, code, value);
 149
 150         if (type != EV_LED)
 151                 return -1;
 152
 153         newleds = (!!test_bit(LED_KANA,    dev->led) << 3) |
 154                   (!!test_bit(LED_COMPOSE, dev->led) << 3) |
 155                   (!!test_bit(LED_SCROLLL, dev->led) << 2) |
 156                   (!!test_bit(LED_CAPSL,   dev->led) << 1) |
 157                   (!!test_bit(LED_NUML,    dev->led));
 158
 159         if (session->leds == newleds)
 160                 return 0;
 161
 162         session->leds = newleds;
 163
 164         hdr = HIDP_TRANS_DATA | HIDP_DATA_RTYPE_OUPUT;
 165         data[0] = 0x01;
 166         data[1] = newleds;
 167
 168         return hidp_send_intr_message(session, hdr, data, 2);
 169 }
 170
 171 static void hidp_input_report(struct hidp_session *session, struct sk_buff *skb)
 172 {
 173         struct input_dev *dev = session->input;
 174         unsigned char *keys = session->keys;
 175         unsigned char *udata = skb->data + 1;
 176         signed char *sdata = skb->data + 1;
 177         int i, size = skb->len - 1;
 178
 179         switch (skb->data[0]) {
 180         case 0x01:      /* Keyboard report */
 181                 for (i = 0; i < 8; i++)
 182                         input_report_key(dev, hidp_keycode[i + 224], (udata[0] >> i) & 1);
 183
 184                 /* If all the key codes have been set to 0x01, it means
 185                  * too many keys were pressed at the same time. */
 186                 if (!memcmp(udata + 2, hidp_mkeyspat, 6))
 187                         break;
 188
 189                 for (i = 2; i < 8; i++) {
 190                         if (keys[i] > 3 && memscan(udata + 2, keys[i], 6) == udata + 8) {
 191                                 if (hidp_keycode[keys[i]])
 192                                         input_report_key(dev, hidp_keycode[keys[i]], 0);
 193                                 else
 194                                         BT_ERR("Unknown key (scancode %#x) released.", keys[i]);
 195                         }
 196
 197                         if (udata[i] > 3 && memscan(keys + 2, udata[i], 6) == keys + 8) {
 198                                 if (hidp_keycode[udata[i]])
 199                                         input_report_key(dev, hidp_keycode[udata[i]], 1);
 200                                 else
 201                                         BT_ERR("Unknown key (scancode %#x) pressed.", udata[i]);
 202                         }
 203                 }
 204
 205                 memcpy(keys, udata, 8);
 206                 break;
 207
 208         case 0x02:      /* Mouse report */
 209                 input_report_key(dev, BTN_LEFT,   sdata[0] & 0x01);
 210                 input_report_key(dev, BTN_RIGHT,  sdata[0] & 0x02);
 211                 input_report_key(dev, BTN_MIDDLE, sdata[0] & 0x04);
 212                 input_report_key(dev, BTN_SIDE,   sdata[0] & 0x08);
 213                 input_report_key(dev, BTN_EXTRA,  sdata[0] & 0x10);
 214
 215                 input_report_rel(dev, REL_X, sdata[1]);
 216                 input_report_rel(dev, REL_Y, sdata[2]);
 217
 218                 if (size > 3)
 219                         input_report_rel(dev, REL_WHEEL, sdata[3]);
 220                 break;
 221         }
 222
 223         input_sync(dev);
 224 }
 225
 226 static int hidp_send_report(struct hidp_session *session, struct hid_report *report)
 227 {
 228         unsigned char buf[32], hdr;
 229         int rsize;
 230
 231         rsize = ((report->size - 1) >> 3) + 1 + (report->id > 0);
 232         if (rsize > sizeof(buf))
 233                 return -EIO;
 234
 235         hid_output_report(report, buf);
 236         hdr = HIDP_TRANS_DATA | HIDP_DATA_RTYPE_OUPUT;
 237
 238         return hidp_send_intr_message(session, hdr, buf, rsize);
 239 }
 240
 241 static int hidp_get_raw_report(struct hid_device *hid,
 242                 unsigned char report_number,
 243                 unsigned char *data, size_t count,
 244                 unsigned char report_type)
 245 {
 246         struct hidp_session *session = hid->driver_data;
 247         struct sk_buff *skb;
 248         size_t len;
 249         int numbered_reports = hid->report_enum[report_type].numbered;
 250         int ret;
 251
 252         if (atomic_read(&session->terminate))
 253                 return -EIO;
 254
 255         switch (report_type) {
 256         case HID_FEATURE_REPORT:
 257                 report_type = HIDP_TRANS_GET_REPORT | HIDP_DATA_RTYPE_FEATURE;
 258                 break;
 259         case HID_INPUT_REPORT:
 260                 report_type = HIDP_TRANS_GET_REPORT | HIDP_DATA_RTYPE_INPUT;
 261                 break;
 262         case HID_OUTPUT_REPORT:
 263                 report_type = HIDP_TRANS_GET_REPORT | HIDP_DATA_RTYPE_OUPUT;
 264                 break;
 265         default:
 266                 return -EINVAL;
 267         }
 268
 269         if (mutex_lock_interruptible(&session->report_mutex))
 270                 return -ERESTARTSYS;
 271
 272         /* Set up our wait, and send the report request to the device. */
 273         session->waiting_report_type = report_type & HIDP_DATA_RTYPE_MASK;
 274         session->waiting_report_number = numbered_reports ? report_number : -1;
 275         set_bit(HIDP_WAITING_FOR_RETURN, &session->flags);
 276         data[0] = report_number;
 277         ret = hidp_send_ctrl_message(session, report_type, data, 1);
 278         if (ret)
 279                 goto err;
 280
 281         /* Wait for the return of the report. The returned report
 282            gets put in session->report_return.  */
 283         while (test_bit(HIDP_WAITING_FOR_RETURN, &session->flags) &&
 284                !atomic_read(&session->terminate)) {
 285                 int res;
 286
 287                 res = wait_event_interruptible_timeout(session->report_queue,
 288                         !test_bit(HIDP_WAITING_FOR_RETURN, &session->flags)
 289                                 || atomic_read(&session->terminate),
 290                         5*HZ);
 291                 if (res == 0) {
 292                         /* timeout */
 293                         ret = -EIO;
 294                         goto err;
 295                 }
 296                 if (res < 0) {
 297                         /* signal */
 298                         ret = -ERESTARTSYS;
 299                         goto err;
 300                 }
 301         }
 302
 303         skb = session->report_return;
 304         if (skb) {
 305                 len = skb->len < count ? skb->len : count;
 306                 memcpy(data, skb->data, len);
 307
 308                 kfree_skb(skb);
 309                 session->report_return = NULL;
 310         } else {
 311                 /* Device returned a HANDSHAKE, indicating  protocol error. */
 312                 len = -EIO;
 313         }
 314
 315         clear_bit(HIDP_WAITING_FOR_RETURN, &session->flags);
 316         mutex_unlock(&session->report_mutex);
 317
 318         return len;
 319
 320 err:
 321         clear_bit(HIDP_WAITING_FOR_RETURN, &session->flags);
 322         mutex_unlock(&session->report_mutex);
 323         return ret;
 324 }
 325
 326 static int hidp_output_raw_report(struct hid_device *hid, unsigned char *data, size_t count,
 327                 unsigned char report_type)
 328 {
 329         struct hidp_session *session = hid->driver_data;
 330         int ret;
 331
 332         if (report_type == HID_OUTPUT_REPORT) {
 333                 report_type = HIDP_TRANS_DATA | HIDP_DATA_RTYPE_OUPUT;
 334                 return hidp_send_intr_message(session, report_type,
 335                                               data, count);
 336         } else if (report_type != HID_FEATURE_REPORT) {
 337                 return -EINVAL;
 338         }
 339
 340         if (mutex_lock_interruptible(&session->report_mutex))
 341                 return -ERESTARTSYS;
 342
 343         /* Set up our wait, and send the report request to the device. */
 344         set_bit(HIDP_WAITING_FOR_SEND_ACK, &session->flags);
 345         report_type = HIDP_TRANS_SET_REPORT | HIDP_DATA_RTYPE_FEATURE;
 346         ret = hidp_send_ctrl_message(session, report_type, data, count);
 347         if (ret)
 348                 goto err;
 349
 350         /* Wait for the ACK from the device. */
 351         while (test_bit(HIDP_WAITING_FOR_SEND_ACK, &session->flags) &&
 352                !atomic_read(&session->terminate)) {
 353                 int res;
 354
 355                 res = wait_event_interruptible_timeout(session->report_queue,
 356                         !test_bit(HIDP_WAITING_FOR_SEND_ACK, &session->flags)
 357                                 || atomic_read(&session->terminate),
 358                         10*HZ);
 359                 if (res == 0) {
 360                         /* timeout */
 361                         ret = -EIO;
 362                         goto err;
 363                 }
 364                 if (res < 0) {
 365                         /* signal */
 366                         ret = -ERESTARTSYS;
 367                         goto err;
 368                 }
 369         }
 370
 371         if (!session->output_report_success) {
 372                 ret = -EIO;
 373                 goto err;
 374         }
 375
 376         ret = count;
 377
 378 err:
 379         clear_bit(HIDP_WAITING_FOR_SEND_ACK, &session->flags);
 380         mutex_unlock(&session->report_mutex);
 381         return ret;
 382 }
 383
 384 static void hidp_idle_timeout(unsigned long arg)
 385 {
 386         struct hidp_session *session = (struct hidp_session *) arg;
 387
 388         hidp_session_terminate(session);
 389 }
 390
 391 static void hidp_set_timer(struct hidp_session *session)
 392 {
 393         if (session->idle_to > 0)
 394                 mod_timer(&session->timer, jiffies + HZ * session->idle_to);
 395 }
 396
 397 static void hidp_del_timer(struct hidp_session *session)
 398 {
 399         if (session->idle_to > 0)
 400                 del_timer(&session->timer);
 401 }
 402
 403 static void hidp_process_handshake(struct hidp_session *session,
 404                                         unsigned char param)
 405 {
 406         BT_DBG("session %p param 0x%02x", session, param);
 407         session->output_report_success = 0; /* default condition */
 408
 409         switch (param) {
 410         case HIDP_HSHK_SUCCESSFUL:
 411                 /* FIXME: Call into SET_ GET_ handlers here */
 412                 session->output_report_success = 1;
 413                 break;
 414
 415         case HIDP_HSHK_NOT_READY:
 416         case HIDP_HSHK_ERR_INVALID_REPORT_ID:
 417         case HIDP_HSHK_ERR_UNSUPPORTED_REQUEST:
 418         case HIDP_HSHK_ERR_INVALID_PARAMETER:
 419                 if (test_and_clear_bit(HIDP_WAITING_FOR_RETURN, &session->flags))
 420                         wake_up_interruptible(&session->report_queue);
 421
 422                 /* FIXME: Call into SET_ GET_ handlers here */
 423                 break;
 424
 425         case HIDP_HSHK_ERR_UNKNOWN:
 426                 break;
 427
 428         case HIDP_HSHK_ERR_FATAL:
 429                 /* Device requests a reboot, as this is the only way this error
 430                  * can be recovered. */
 431                 hidp_send_ctrl_message(session,
 432                         HIDP_TRANS_HID_CONTROL | HIDP_CTRL_SOFT_RESET, NULL, 0);
 433                 break;
 434
 435         default:
 436                 hidp_send_ctrl_message(session,
 437                         HIDP_TRANS_HANDSHAKE | HIDP_HSHK_ERR_INVALID_PARAMETER, NULL, 0);
 438                 break;
 439         }
 440
 441         /* Wake up the waiting thread. */
 442         if (test_and_clear_bit(HIDP_WAITING_FOR_SEND_ACK, &session->flags))
 443                 wake_up_interruptible(&session->report_queue);
 444 }
 445
 446 static void hidp_process_hid_control(struct hidp_session *session,
 447                                         unsigned char param)
 448 {
 449         BT_DBG("session %p param 0x%02x", session, param);
 450
 451         if (param == HIDP_CTRL_VIRTUAL_CABLE_UNPLUG) {
 452                 /* Flush the transmit queues */
 453                 skb_queue_purge(&session->ctrl_transmit);
 454                 skb_queue_purge(&session->intr_transmit);
 455
 456                 hidp_session_terminate(session);
 457         }
 458 }
 459
 460 /* Returns true if the passed-in skb should be freed by the caller. */
 461 static int hidp_process_data(struct hidp_session *session, struct sk_buff *skb,
 462                                 unsigned char param)
 463 {
 464         int done_with_skb = 1;
 465         BT_DBG("session %p skb %p len %d param 0x%02x", session, skb, skb->len, param);
 466
 467         switch (param) {
 468         case HIDP_DATA_RTYPE_INPUT:
 469                 hidp_set_timer(session);
 470
 471                 if (session->input)
 472                         hidp_input_report(session, skb);
 473
 474                 if (session->hid)
 475                         hid_input_report(session->hid, HID_INPUT_REPORT, skb->data, skb->len, 0);
 476                 break;
 477
 478         case HIDP_DATA_RTYPE_OTHER:
 479         case HIDP_DATA_RTYPE_OUPUT:
 480         case HIDP_DATA_RTYPE_FEATURE:
 481                 break;
 482
 483         default:
 484                 hidp_send_ctrl_message(session,
 485                         HIDP_TRANS_HANDSHAKE | HIDP_HSHK_ERR_INVALID_PARAMETER, NULL, 0);
 486         }
 487
 488         if (test_bit(HIDP_WAITING_FOR_RETURN, &session->flags) &&
 489                                 param == session->waiting_report_type) {
 490                 if (session->waiting_report_number < 0 ||
 491                     session->waiting_report_number == skb->data[0]) {
 492                         /* hidp_get_raw_report() is waiting on this report. */
 493                         session->report_return = skb;
 494                         done_with_skb = 0;
 495                         clear_bit(HIDP_WAITING_FOR_RETURN, &session->flags);
 496                         wake_up_interruptible(&session->report_queue);
 497                 }
 498         }
 499
 500         return done_with_skb;
 501 }
 502
 503 static void hidp_recv_ctrl_frame(struct hidp_session *session,
 504                                         struct sk_buff *skb)
 505 {
 506         unsigned char hdr, type, param;
 507         int free_skb = 1;
 508
 509         BT_DBG("session %p skb %p len %d", session, skb, skb->len);
 510
 511         hdr = skb->data[0];
 512         skb_pull(skb, 1);
 513
 514         type = hdr & HIDP_HEADER_TRANS_MASK;
 515         param = hdr & HIDP_HEADER_PARAM_MASK;
 516
 517         switch (type) {
 518         case HIDP_TRANS_HANDSHAKE:
 519                 hidp_process_handshake(session, param);
 520                 break;
 521
 522         case HIDP_TRANS_HID_CONTROL:
 523                 hidp_process_hid_control(session, param);
 524                 break;
 525
 526         case HIDP_TRANS_DATA:
 527                 free_skb = hidp_process_data(session, skb, param);
 528                 break;
 529
 530         default:
 531                 hidp_send_ctrl_message(session,
 532                         HIDP_TRANS_HANDSHAKE | HIDP_HSHK_ERR_UNSUPPORTED_REQUEST, NULL, 0);
 533                 break;
 534         }
 535
 536         if (free_skb)
 537                 kfree_skb(skb);
 538 }
 539
 540 static void hidp_recv_intr_frame(struct hidp_session *session,
 541                                 struct sk_buff *skb)
 542 {
 543         unsigned char hdr;
 544
 545         BT_DBG("session %p skb %p len %d", session, skb, skb->len);
 546
 547         hdr = skb->data[0];
 548         skb_pull(skb, 1);
 549
 550         if (hdr == (HIDP_TRANS_DATA | HIDP_DATA_RTYPE_INPUT)) {
 551                 hidp_set_timer(session);
 552
 553                 if (session->input)
 554                         hidp_input_report(session, skb);
 555
 556                 if (session->hid) {
 557                         hid_input_report(session->hid, HID_INPUT_REPORT, skb->data, skb->len, 1);
 558                         BT_DBG("report len %d", skb->len);
 559                 }
 560         } else {
 561                 BT_DBG("Unsupported protocol header 0x%02x", hdr);
 562         }
 563
 564         kfree_skb(skb);
 565 }
 566
 567 static int hidp_send_frame(struct socket *sock, unsigned char *data, int len)
 568 {
 569         struct kvec iv = { data, len };
 570         struct msghdr msg;
 571
 572         BT_DBG("sock %p data %p len %d", sock, data, len);
 573
 574         if (!len)
 575                 return 0;
 576
 577         memset(&msg, 0, sizeof(msg));
 578
 579         return kernel_sendmsg(sock, &msg, &iv, 1, len);
 580 }
 581
 582 /* dequeue message from @transmit and send via @sock */
 583 static void hidp_process_transmit(struct hidp_session *session,
 584                                   struct sk_buff_head *transmit,
 585                                   struct socket *sock)
 586 {
 587         struct sk_buff *skb;
 588         int ret;
 589
 590         BT_DBG("session %p", session);
 591
 592         while ((skb = skb_dequeue(transmit))) {
 593                 ret = hidp_send_frame(sock, skb->data, skb->len);
 594                 if (ret == -EAGAIN) {
 595                         skb_queue_head(transmit, skb);
 596                         break;
 597                 } else if (ret < 0) {
 598                         hidp_session_terminate(session);
 599                         kfree_skb(skb);
 600                         break;
 601                 }
 602
 603                 hidp_set_timer(session);
 604                 kfree_skb(skb);
 605         }
 606 }
 607
 608 static int hidp_setup_input(struct hidp_session *session,
 609                                 struct hidp_connadd_req *req)
 610 {
 611         struct input_dev *input;
 612         int i;
 613
 614         input = input_allocate_device();
 615         if (!input)
 616                 return -ENOMEM;
 617
 618         session->input = input;
 619
 620         input_set_drvdata(input, session);
 621
 622         input->name = "Bluetooth HID Boot Protocol Device";
 623
 624         input->id.bustype = BUS_BLUETOOTH;
 625         input->id.vendor  = req->vendor;
 626         input->id.product = req->product;
 627         input->id.version = req->version;
 628
 629         if (req->subclass & 0x40) {
 630                 set_bit(EV_KEY, input->evbit);
 631                 set_bit(EV_LED, input->evbit);
 632                 set_bit(EV_REP, input->evbit);
 633
 634                 set_bit(LED_NUML,    input->ledbit);
 635                 set_bit(LED_CAPSL,   input->ledbit);
 636                 set_bit(LED_SCROLLL, input->ledbit);
 637                 set_bit(LED_COMPOSE, input->ledbit);
 638                 set_bit(LED_KANA,    input->ledbit);
 639
 640                 for (i = 0; i < sizeof(hidp_keycode); i++)
 641                         set_bit(hidp_keycode[i], input->keybit);
 642                 clear_bit(0, input->keybit);
 643         }
 644
 645         if (req->subclass & 0x80) {
 646                 input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL);
 647                 input->keybit[BIT_WORD(BTN_MOUSE)] = BIT_MASK(BTN_LEFT) |
 648                         BIT_MASK(BTN_RIGHT) | BIT_MASK(BTN_MIDDLE);
 649                 input->relbit[0] = BIT_MASK(REL_X) | BIT_MASK(REL_Y);
 650                 input->keybit[BIT_WORD(BTN_MOUSE)] |= BIT_MASK(BTN_SIDE) |
 651                         BIT_MASK(BTN_EXTRA);
 652                 input->relbit[0] |= BIT_MASK(REL_WHEEL);
 653         }
 654
 655         input->dev.parent = &session->conn->hcon->dev;
 656
 657         input->event = hidp_input_event;
 658
 659         return 0;
 660 }
 661
 662 static int hidp_open(struct hid_device *hid)
 663 {
 664         return 0;
 665 }
 666
 667 static void hidp_close(struct hid_device *hid)
 668 {
 669 }
 670
 671 static int hidp_parse(struct hid_device *hid)
 672 {
 673         struct hidp_session *session = hid->driver_data;
 674
 675         return hid_parse_report(session->hid, session->rd_data,
 676                         session->rd_size);
 677 }
 678
 679 static int hidp_start(struct hid_device *hid)
 680 {
 681         struct hidp_session *session = hid->driver_data;
 682         struct hid_report *report;
 683
 684         if (hid->quirks & HID_QUIRK_NO_INIT_REPORTS)
 685                 return 0;
 686
 687         list_for_each_entry(report, &hid->report_enum[HID_INPUT_REPORT].
 688                         report_list, list)
 689                 hidp_send_report(session, report);
 690
 691         list_for_each_entry(report, &hid->report_enum[HID_FEATURE_REPORT].
 692                         report_list, list)
 693                 hidp_send_report(session, report);
 694
 695         return 0;
 696 }
 697
 698 static void hidp_stop(struct hid_device *hid)
 699 {
 700         struct hidp_session *session = hid->driver_data;
 701
 702         skb_queue_purge(&session->ctrl_transmit);
 703         skb_queue_purge(&session->intr_transmit);
 704
 705         hid->claimed = 0;
 706 }
 707
 708 static struct hid_ll_driver hidp_hid_driver = {
 709         .parse = hidp_parse,
 710         .start = hidp_start,
 711         .stop = hidp_stop,
 712         .open  = hidp_open,
 713         .close = hidp_close,
 714 };
 715
 716 /* This function sets up the hid device. It does not add it
 717    to the HID system. That is done in hidp_add_connection(). */
 718 static int hidp_setup_hid(struct hidp_session *session,
 719                                 struct hidp_connadd_req *req)
 720 {
 721         struct hid_device *hid;
 722         int err;
 723
 724         session->rd_data = kzalloc(req->rd_size, GFP_KERNEL);
 725         if (!session->rd_data)
 726                 return -ENOMEM;
 727
 728         if (copy_from_user(session->rd_data, req->rd_data, req->rd_size)) {
 729                 err = -EFAULT;
 730                 goto fault;
 731         }
 732         session->rd_size = req->rd_size;
 733
 734         hid = hid_allocate_device();
 735         if (IS_ERR(hid)) {
 736                 err = PTR_ERR(hid);
 737                 goto fault;
 738         }
 739
 740         session->hid = hid;
 741
 742         hid->driver_data = session;
 743
 744         hid->bus     = BUS_BLUETOOTH;
 745         hid->vendor  = req->vendor;
 746         hid->product = req->product;
 747         hid->version = req->version;
 748         hid->country = req->country;
 749
 750         strncpy(hid->name, req->name, sizeof(req->name) - 1);
 751
 752         snprintf(hid->phys, sizeof(hid->phys), "%pMR",
 753                  &bt_sk(session->ctrl_sock->sk)->src);
 754
 755         snprintf(hid->uniq, sizeof(hid->uniq), "%pMR",
 756                  &bt_sk(session->ctrl_sock->sk)->dst);
 757
 758         hid->dev.parent = &session->conn->hcon->dev;
 759         hid->ll_driver = &hidp_hid_driver;
 760
 761         hid->hid_get_raw_report = hidp_get_raw_report;
 762         hid->hid_output_raw_report = hidp_output_raw_report;
 763
 764         /* True if device is blacklisted in drivers/hid/hid-core.c */
 765         if (hid_ignore(hid)) {
 766                 hid_destroy_device(session->hid);
 767                 session->hid = NULL;
 768                 return -ENODEV;
 769         }
 770
 771         return 0;
 772
 773 fault:
 774         kfree(session->rd_data);
 775         session->rd_data = NULL;
 776
 777         return err;
 778 }
 779
 780 /* initialize session devices */
 781 static int hidp_session_dev_init(struct hidp_session *session,
 782                                  struct hidp_connadd_req *req)
 783 {
 784         int ret;
 785
 786         if (req->rd_size > 0) {
 787                 ret = hidp_setup_hid(session, req);
 788                 if (ret && ret != -ENODEV)
 789                         return ret;
 790         }
 791
 792         if (!session->hid) {
 793                 ret = hidp_setup_input(session, req);
 794                 if (ret < 0)
 795                         return ret;
 796         }
 797
 798         return 0;
 799 }
 800
 801 /* destroy session devices */
 802 static void hidp_session_dev_destroy(struct hidp_session *session)
 803 {
 804         if (session->hid)
 805                 put_device(&session->hid->dev);
 806         else if (session->input)
 807                 input_put_device(session->input);
 808
 809         kfree(session->rd_data);
 810         session->rd_data = NULL;
 811 }
 812
 813 /* add HID/input devices to their underlying bus systems */
 814 static int hidp_session_dev_add(struct hidp_session *session)
 815 {
 816         int ret;
 817
 818         /* Both HID and input systems drop a ref-count when unregistering the
 819          * device but they don't take a ref-count when registering them. Work
 820          * around this by explicitly taking a refcount during registration
 821          * which is dropped automatically by unregistering the devices. */
 822
 823         if (session->hid) {
 824                 ret = hid_add_device(session->hid);
 825                 if (ret)
 826                         return ret;
 827                 get_device(&session->hid->dev);
 828         } else if (session->input) {
 829                 ret = input_register_device(session->input);
 830                 if (ret)
 831                         return ret;
 832                 input_get_device(session->input);
 833         }
 834
 835         return 0;
 836 }
 837
 838 /* remove HID/input devices from their bus systems */
 839 static void hidp_session_dev_del(struct hidp_session *session)
 840 {
 841         if (session->hid)
 842                 hid_destroy_device(session->hid);
 843         else if (session->input)
 844                 input_unregister_device(session->input);
 845 }
 846
 847 /*
 848  * Create new session object
 849  * Allocate session object, initialize static fields, copy input data into the
 850  * object and take a reference to all sub-objects.
 851  * This returns 0 on success and puts a pointer to the new session object in
 852  * \out. Otherwise, an error code is returned.
 853  * The new session object has an initial ref-count of 1.
 854  */
 855 static int hidp_session_new(struct hidp_session **out, const bdaddr_t *bdaddr,
 856                             struct socket *ctrl_sock,
 857                             struct socket *intr_sock,
 858                             struct hidp_connadd_req *req,
 859                             struct l2cap_conn *conn)
 860 {
 861         struct hidp_session *session;
 862         int ret;
 863         struct bt_sock *ctrl, *intr;
 864
 865         ctrl = bt_sk(ctrl_sock->sk);
 866         intr = bt_sk(intr_sock->sk);
 867
 868         session = kzalloc(sizeof(*session), GFP_KERNEL);
 869         if (!session)
 870                 return -ENOMEM;
 871
 872         /* object and runtime management */
 873         kref_init(&session->ref);
 874         atomic_set(&session->state, HIDP_SESSION_IDLING);
 875         init_waitqueue_head(&session->state_queue);
 876         session->flags = req->flags & (1 << HIDP_BLUETOOTH_VENDOR_ID);
 877
 878         /* connection management */
 879         bacpy(&session->bdaddr, bdaddr);
 880         session->conn = conn;
 881         session->user.probe = hidp_session_probe;
 882         session->user.remove = hidp_session_remove;
 883         session->ctrl_sock = ctrl_sock;
 884         session->intr_sock = intr_sock;
 885         skb_queue_head_init(&session->ctrl_transmit);
 886         skb_queue_head_init(&session->intr_transmit);
 887         session->ctrl_mtu = min_t(uint, l2cap_pi(ctrl)->chan->omtu,
 888                                         l2cap_pi(ctrl)->chan->imtu);
 889         session->intr_mtu = min_t(uint, l2cap_pi(intr)->chan->omtu,
 890                                         l2cap_pi(intr)->chan->imtu);
 891         session->idle_to = req->idle_to;
 892
 893         /* device management */
 894         setup_timer(&session->timer, hidp_idle_timeout,
 895                     (unsigned long)session);
 896
 897         /* session data */
 898         mutex_init(&session->report_mutex);
 899         init_waitqueue_head(&session->report_queue);
 900
 901         ret = hidp_session_dev_init(session, req);
 902         if (ret)
 903                 goto err_free;
 904
 905         l2cap_conn_get(session->conn);
 906         get_file(session->intr_sock->file);
 907         get_file(session->ctrl_sock->file);
 908         *out = session;
 909         return 0;
 910
 911 err_free:
 912         kfree(session);
 913         return ret;
 914 }
 915
 916 /* increase ref-count of the given session by one */
 917 static void hidp_session_get(struct hidp_session *session)
 918 {
 919         kref_get(&session->ref);
 920 }
 921
 922 /* release callback */
 923 static void session_free(struct kref *ref)
 924 {
 925         struct hidp_session *session = container_of(ref, struct hidp_session,
 926                                                     ref);
 927
 928         hidp_session_dev_destroy(session);
 929         skb_queue_purge(&session->ctrl_transmit);
 930         skb_queue_purge(&session->intr_transmit);
 931         fput(session->intr_sock->file);
 932         fput(session->ctrl_sock->file);
 933         l2cap_conn_put(session->conn);
 934         kfree(session);
 935 }
 936
 937 /* decrease ref-count of the given session by one */
 938 static void hidp_session_put(struct hidp_session *session)
 939 {
 940         kref_put(&session->ref, session_free);
 941 }
 942
 943 /*
 944  * Search the list of active sessions for a session with target address
 945  * \bdaddr. You must hold at least a read-lock on \hidp_session_sem. As long as
 946  * you do not release this lock, the session objects cannot vanish and you can
 947  * safely take a reference to the session yourself.
 948  */
 949 static struct hidp_session *__hidp_session_find(const bdaddr_t *bdaddr)
 950 {
 951         struct hidp_session *session;
 952
 953         list_for_each_entry(session, &hidp_session_list, list) {
 954                 if (!bacmp(bdaddr, &session->bdaddr))
 955                         return session;
 956         }
 957
 958         return NULL;
 959 }
 960
 961 /*
 962  * Same as __hidp_session_find() but no locks must be held. This also takes a
 963  * reference of the returned session (if non-NULL) so you must drop this
 964  * reference if you no longer use the object.
 965  */
 966 static struct hidp_session *hidp_session_find(const bdaddr_t *bdaddr)
 967 {
 968         struct hidp_session *session;
 969
 970         down_read(&hidp_session_sem);
 971
 972         session = __hidp_session_find(bdaddr);
 973         if (session)
 974                 hidp_session_get(session);
 975
 976         up_read(&hidp_session_sem);
 977
 978         return session;
 979 }
 980
 981 /*
 982  * Start session synchronously
 983  * This starts a session thread and waits until initialization
 984  * is done or returns an error if it couldn't be started.
 985  * If this returns 0 the session thread is up and running. You must call
 986  * hipd_session_stop_sync() before deleting any runtime resources.
 987  */
 988 static int hidp_session_start_sync(struct hidp_session *session)
 989 {
 990         unsigned int vendor, product;
 991
 992         if (session->hid) {
 993                 vendor  = session->hid->vendor;
 994                 product = session->hid->product;
 995         } else if (session->input) {
 996                 vendor  = session->input->id.vendor;
 997                 product = session->input->id.product;
 998         } else {
 999                 vendor = 0x0000;
1000                 product = 0x0000;
1001         }
1002
1003         session->task = kthread_run(hidp_session_thread, session,
1004                                     "khidpd_%04x%04x", vendor, product);
1005         if (IS_ERR(session->task))
1006                 return PTR_ERR(session->task);
1007
1008         while (atomic_read(&session->state) <= HIDP_SESSION_IDLING)
1009                 wait_event(session->state_queue,
1010                            atomic_read(&session->state) > HIDP_SESSION_IDLING);
1011
1012         return 0;
1013 }
1014
1015 /*
1016  * Terminate session thread
1017  * Wake up session thread and notify it to stop. This is asynchronous and
1018  * returns immediately. Call this whenever a runtime error occurs and you want
1019  * the session to stop.
1020  * Note: wake_up_process() performs any necessary memory-barriers for us.
1021  */
1022 static void hidp_session_terminate(struct hidp_session *session)
1023 {
1024         atomic_inc(&session->terminate);
1025         wake_up_process(session->task);
1026 }
1027
1028 /*
1029  * Probe HIDP session
1030  * This is called from the l2cap_conn core when our l2cap_user object is bound
1031  * to the hci-connection. We get the session via the \user object and can now
1032  * start the session thread, register the HID/input devices and link it into
1033  * the global session list.
1034  * The global session-list owns its own reference to the session object so you
1035  * can drop your own reference after registering the l2cap_user object.
1036  */
1037 static int hidp_session_probe(struct l2cap_conn *conn,
1038                               struct l2cap_user *user)
1039 {
1040         struct hidp_session *session = container_of(user,
1041                                                     struct hidp_session,
1042                                                     user);
1043         struct hidp_session *s;
1044         int ret;
1045
1046         down_write(&hidp_session_sem);
1047
1048         /* check that no other session for this device exists */
1049         s = __hidp_session_find(&session->bdaddr);
1050         if (s) {
1051                 ret = -EEXIST;
1052                 goto out_unlock;
1053         }
1054
1055         ret = hidp_session_start_sync(session);
1056         if (ret)
1057                 goto out_unlock;
1058
1059         ret = hidp_session_dev_add(session);
1060         if (ret)
1061                 goto out_stop;
1062
1063         hidp_session_get(session);
1064         list_add(&session->list, &hidp_session_list);
1065         ret = 0;
1066         goto out_unlock;
1067
1068 out_stop:
1069         hidp_session_terminate(session);
1070 out_unlock:
1071         up_write(&hidp_session_sem);
1072         return ret;
1073 }
1074
1075 /*
1076  * Remove HIDP session
1077  * Called from the l2cap_conn core when either we explicitly unregistered
1078  * the l2cap_user object or if the underlying connection is shut down.
1079  * We signal the hidp-session thread to shut down, unregister the HID/input
1080  * devices and unlink the session from the global list.
1081  * This drops the reference to the session that is owned by the global
1082  * session-list.
1083  * Note: We _must_ not synchronosly wait for the session-thread to shut down.
1084  * This is, because the session-thread might be waiting for an HCI lock that is
1085  * held while we are called. Therefore, we only unregister the devices and
1086  * notify the session-thread to terminate. The thread itself owns a reference
1087  * to the session object so it can safely shut down.
1088  */
1089 static void hidp_session_remove(struct l2cap_conn *conn,
1090                                 struct l2cap_user *user)
1091 {
1092         struct hidp_session *session = container_of(user,
1093                                                     struct hidp_session,
1094                                                     user);
1095
1096         down_write(&hidp_session_sem);
1097
1098         hidp_session_terminate(session);
1099         hidp_session_dev_del(session);
1100         list_del(&session->list);
1101
1102         up_write(&hidp_session_sem);
1103
1104         hidp_session_put(session);
1105 }
1106
1107 /*
1108  * Session Worker
1109  * This performs the actual main-loop of the HIDP worker. We first check
1110  * whether the underlying connection is still alive, then parse all pending
1111  * messages and finally send all outstanding messages.
1112  */
1113 static void hidp_session_run(struct hidp_session *session)
1114 {
1115         struct sock *ctrl_sk = session->ctrl_sock->sk;
1116         struct sock *intr_sk = session->intr_sock->sk;
1117         struct sk_buff *skb;
1118
1119         for (;;) {
1120                 /*
1121                  * This thread can be woken up two ways:
1122                  *  - You call hidp_session_terminate() which sets the
1123                  *    session->terminate flag and wakes this thread up.
1124                  *  - Via modifying the socket state of ctrl/intr_sock. This
1125                  *    thread is woken up by ->sk_state_changed().
1126                  *
1127                  * Note: set_current_state() performs any necessary
1128                  * memory-barriers for us.
1129                  */
1130                 set_current_state(TASK_INTERRUPTIBLE);
1131
1132                 if (atomic_read(&session->terminate))
1133                         break;
1134
1135                 if (ctrl_sk->sk_state != BT_CONNECTED ||
1136                     intr_sk->sk_state != BT_CONNECTED)
1137                         break;
1138
1139                 /* parse incoming intr-skbs */
1140                 while ((skb = skb_dequeue(&intr_sk->sk_receive_queue))) {
1141                         skb_orphan(skb);
1142                         if (!skb_linearize(skb))
1143                                 hidp_recv_intr_frame(session, skb);
1144                         else
1145                                 kfree_skb(skb);
1146                 }
1147
1148                 /* send pending intr-skbs */
1149                 hidp_process_transmit(session, &session->intr_transmit,
1150                                       session->intr_sock);
1151
1152                 /* parse incoming ctrl-skbs */
1153                 while ((skb = skb_dequeue(&ctrl_sk->sk_receive_queue))) {
1154                         skb_orphan(skb);
1155                         if (!skb_linearize(skb))
1156                                 hidp_recv_ctrl_frame(session, skb);
1157                         else
1158                                 kfree_skb(skb);
1159                 }
1160
1161                 /* send pending ctrl-skbs */
1162                 hidp_process_transmit(session, &session->ctrl_transmit,
1163                                       session->ctrl_sock);
1164
1165                 schedule();
1166         }
1167
1168         atomic_inc(&session->terminate);
1169         set_current_state(TASK_RUNNING);
1170 }
1171
1172 /*
1173  * HIDP session thread
1174  * This thread runs the I/O for a single HIDP session. Startup is synchronous
1175  * which allows us to take references to ourself here instead of doing that in
1176  * the caller.
1177  * When we are ready to run we notify the caller and call hidp_session_run().
1178  */
1179 static int hidp_session_thread(void *arg)
1180 {
1181         struct hidp_session *session = arg;
1182         wait_queue_t ctrl_wait, intr_wait;
1183
1184         BT_DBG("session %p", session);
1185
1186         /* initialize runtime environment */
1187         hidp_session_get(session);
1188         __module_get(THIS_MODULE);
1189         set_user_nice(current, -15);
1190         hidp_set_timer(session);
1191
1192         init_waitqueue_entry(&ctrl_wait, current);
1193         init_waitqueue_entry(&intr_wait, current);
1194         add_wait_queue(sk_sleep(session->ctrl_sock->sk), &ctrl_wait);
1195         add_wait_queue(sk_sleep(session->intr_sock->sk), &intr_wait);
1196         /* This memory barrier is paired with wq_has_sleeper(). See
1197          * sock_poll_wait() for more information why this is needed. */
1198         smp_mb();
1199
1200         /* notify synchronous startup that we're ready */
1201         atomic_inc(&session->state);
1202         wake_up(&session->state_queue);
1203
1204         /* run session */
1205         hidp_session_run(session);
1206
1207         /* cleanup runtime environment */
1208         remove_wait_queue(sk_sleep(session->intr_sock->sk), &intr_wait);
1209         remove_wait_queue(sk_sleep(session->intr_sock->sk), &ctrl_wait);
1210         wake_up_interruptible(&session->report_queue);
1211         hidp_del_timer(session);
1212
1213         /*
1214          * If we stopped ourself due to any internal signal, we should try to
1215          * unregister our own session here to avoid having it linger until the
1216          * parent l2cap_conn dies or user-space cleans it up.
1217          * This does not deadlock as we don't do any synchronous shutdown.
1218          * Instead, this call has the same semantics as if user-space tried to
1219          * delete the session.
1220          */
1221         l2cap_unregister_user(session->conn, &session->user);
1222         hidp_session_put(session);
1223
1224         module_put_and_exit(0);
1225         return 0;
1226 }
1227
1228 static int hidp_verify_sockets(struct socket *ctrl_sock,
1229                                struct socket *intr_sock)
1230 {
1231         struct bt_sock *ctrl, *intr;
1232         struct hidp_session *session;
1233
1234         if (!l2cap_is_socket(ctrl_sock) || !l2cap_is_socket(intr_sock))
1235                 return -EINVAL;
1236
1237         ctrl = bt_sk(ctrl_sock->sk);
1238         intr = bt_sk(intr_sock->sk);
1239
1240         if (bacmp(&ctrl->src, &intr->src) || bacmp(&ctrl->dst, &intr->dst))
1241                 return -ENOTUNIQ;
1242         if (ctrl->sk.sk_state != BT_CONNECTED ||
1243             intr->sk.sk_state != BT_CONNECTED)
1244                 return -EBADFD;
1245
1246         /* early session check, we check again during session registration */
1247         session = hidp_session_find(&ctrl->dst);
1248         if (session) {
1249                 hidp_session_put(session);
1250                 return -EEXIST;
1251         }
1252
1253         return 0;
1254 }
1255
1256 int hidp_connection_add(struct hidp_connadd_req *req,
1257                         struct socket *ctrl_sock,
1258                         struct socket *intr_sock)
1259 {
1260         struct hidp_session *session;
1261         struct l2cap_conn *conn;
1262         struct l2cap_chan *chan = l2cap_pi(ctrl_sock->sk)->chan;
1263         int ret;
1264
1265         ret = hidp_verify_sockets(ctrl_sock, intr_sock);
1266         if (ret)
1267                 return ret;
1268
1269         conn = NULL;
1270         l2cap_chan_lock(chan);
1271         if (chan->conn) {
1272                 l2cap_conn_get(chan->conn);
1273                 conn = chan->conn;
1274         }
1275         l2cap_chan_unlock(chan);
1276
1277         if (!conn)
1278                 return -EBADFD;
1279
1280         ret = hidp_session_new(&session, &bt_sk(ctrl_sock->sk)->dst, ctrl_sock,
1281                                intr_sock, req, conn);
1282         if (ret)
1283                 goto out_conn;
1284
1285         ret = l2cap_register_user(conn, &session->user);
1286         if (ret)
1287                 goto out_session;
1288
1289         ret = 0;
1290
1291 out_session:
1292         hidp_session_put(session);
1293 out_conn:
1294         l2cap_conn_put(conn);
1295         return ret;
1296 }
1297
1298 int hidp_connection_del(struct hidp_conndel_req *req)
1299 {
1300         struct hidp_session *session;
1301
1302         session = hidp_session_find(&req->bdaddr);
1303         if (!session)
1304                 return -ENOENT;
1305
1306         if (req->flags & (1 << HIDP_VIRTUAL_CABLE_UNPLUG))
1307                 hidp_send_ctrl_message(session,
1308                                        HIDP_TRANS_HID_CONTROL |
1309                                          HIDP_CTRL_VIRTUAL_CABLE_UNPLUG,
1310                                        NULL, 0);
1311         else
1312                 l2cap_unregister_user(session->conn, &session->user);
1313
1314         hidp_session_put(session);
1315
1316         return 0;
1317 }
1318
1319 int hidp_get_connlist(struct hidp_connlist_req *req)
1320 {
1321         struct hidp_session *session;
1322         int err = 0, n = 0;
1323
1324         BT_DBG("");
1325
1326         down_read(&hidp_session_sem);
1327
1328         list_for_each_entry(session, &hidp_session_list, list) {
1329                 struct hidp_conninfo ci;
1330
1331                 hidp_copy_session(session, &ci);
1332
1333                 if (copy_to_user(req->ci, &ci, sizeof(ci))) {
1334                         err = -EFAULT;
1335                         break;
1336                 }
1337
1338                 if (++n >= req->cnum)
1339                         break;
1340
1341                 req->ci++;
1342         }
1343         req->cnum = n;
1344
1345         up_read(&hidp_session_sem);
1346         return err;
1347 }
1348
1349 int hidp_get_conninfo(struct hidp_conninfo *ci)
1350 {
1351         struct hidp_session *session;
1352
1353         session = hidp_session_find(&ci->bdaddr);
1354         if (session) {
1355                 hidp_copy_session(session, ci);
1356                 hidp_session_put(session);
1357         }
1358
1359         return session ? 0 : -ENOENT;
1360 }
1361
1362 static int __init hidp_init(void)
1363 {
1364         BT_INFO("HIDP (Human Interface Emulation) ver %s", VERSION);
1365
1366         return hidp_init_sockets();
1367 }
1368
1369 static void __exit hidp_exit(void)
1370 {
1371         hidp_cleanup_sockets();
1372 }
1373
1374 module_init(hidp_init);
1375 module_exit(hidp_exit);
1376
1377 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
1378 MODULE_AUTHOR("David Herrmann <dh.herrmann@gmail.com>");
1379 MODULE_DESCRIPTION("Bluetooth HIDP ver " VERSION);
1380 MODULE_VERSION(VERSION);
1381 MODULE_LICENSE("GPL");
1382 MODULE_ALIAS("bt-proto-6");