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