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