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