Linux-2.6.12-rc2
[linux-2.6.git] / net / bluetooth / hidp / core.c
1 /* 
2    HIDP implementation for Linux Bluetooth stack (BlueZ).
3    Copyright (C) 2003-2004 Marcel Holtmann <marcel@holtmann.org>
4
5    This program is free software; you can redistribute it and/or modify
6    it under the terms of the GNU General Public License version 2 as
7    published by the Free Software Foundation;
8
9    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
10    OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
11    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
12    IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
13    CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES 
14    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 
15    ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 
16    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17
18    ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS, 
19    COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS 
20    SOFTWARE IS DISCLAIMED.
21 */
22
23 #include <linux/config.h>
24 #include <linux/module.h>
25
26 #include <linux/types.h>
27 #include <linux/errno.h>
28 #include <linux/kernel.h>
29 #include <linux/major.h>
30 #include <linux/sched.h>
31 #include <linux/slab.h>
32 #include <linux/poll.h>
33 #include <linux/fcntl.h>
34 #include <linux/skbuff.h>
35 #include <linux/socket.h>
36 #include <linux/ioctl.h>
37 #include <linux/file.h>
38 #include <linux/init.h>
39 #include <linux/wait.h>
40 #include <net/sock.h>
41
42 #include <linux/input.h>
43
44 #include <net/bluetooth/bluetooth.h>
45 #include <net/bluetooth/l2cap.h>
46
47 #include "hidp.h"
48
49 #ifndef CONFIG_BT_HIDP_DEBUG
50 #undef  BT_DBG
51 #define BT_DBG(D...)
52 #endif
53
54 #define VERSION "1.1"
55
56 static DECLARE_RWSEM(hidp_session_sem);
57 static LIST_HEAD(hidp_session_list);
58
59 static unsigned char hidp_keycode[256] = {
60           0,  0,  0,  0, 30, 48, 46, 32, 18, 33, 34, 35, 23, 36, 37, 38,
61          50, 49, 24, 25, 16, 19, 31, 20, 22, 47, 17, 45, 21, 44,  2,  3,
62           4,  5,  6,  7,  8,  9, 10, 11, 28,  1, 14, 15, 57, 12, 13, 26,
63          27, 43, 43, 39, 40, 41, 51, 52, 53, 58, 59, 60, 61, 62, 63, 64,
64          65, 66, 67, 68, 87, 88, 99, 70,119,110,102,104,111,107,109,106,
65         105,108,103, 69, 98, 55, 74, 78, 96, 79, 80, 81, 75, 76, 77, 71,
66          72, 73, 82, 83, 86,127,116,117,183,184,185,186,187,188,189,190,
67         191,192,193,194,134,138,130,132,128,129,131,137,133,135,136,113,
68         115,114,  0,  0,  0,121,  0, 89, 93,124, 92, 94, 95,  0,  0,  0,
69         122,123, 90, 91, 85,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
70           0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
71           0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
72           0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
73           0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
74          29, 42, 56,125, 97, 54,100,126,164,166,165,163,161,115,114,113,
75         150,158,159,128,136,177,178,176,142,152,173,140
76 };
77
78 static unsigned char hidp_mkeyspat[] = { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 };
79
80 static struct hidp_session *__hidp_get_session(bdaddr_t *bdaddr)
81 {
82         struct hidp_session *session;
83         struct list_head *p;
84
85         BT_DBG("");
86
87         list_for_each(p, &hidp_session_list) {
88                 session = list_entry(p, struct hidp_session, list);
89                 if (!bacmp(bdaddr, &session->bdaddr))
90                         return session;
91         }
92         return NULL;
93 }
94
95 static void __hidp_link_session(struct hidp_session *session)
96 {
97         __module_get(THIS_MODULE);
98         list_add(&session->list, &hidp_session_list);
99 }
100
101 static void __hidp_unlink_session(struct hidp_session *session)
102 {
103         list_del(&session->list);
104         module_put(THIS_MODULE);
105 }
106
107 static void __hidp_copy_session(struct hidp_session *session, struct hidp_conninfo *ci)
108 {
109         bacpy(&ci->bdaddr, &session->bdaddr);
110
111         ci->flags = session->flags;
112         ci->state = session->state;
113
114         ci->vendor  = 0x0000;
115         ci->product = 0x0000;
116         ci->version = 0x0000;
117         memset(ci->name, 0, 128);
118
119         if (session->input) {
120                 ci->vendor  = session->input->id.vendor;
121                 ci->product = session->input->id.product;
122                 ci->version = session->input->id.version;
123                 if (session->input->name)
124                         strncpy(ci->name, session->input->name, 128);
125                 else
126                         strncpy(ci->name, "HID Boot Device", 128);
127         }
128 }
129
130 static int hidp_input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
131 {
132         struct hidp_session *session = dev->private;
133         struct sk_buff *skb;
134         unsigned char newleds;
135
136         BT_DBG("input %p type %d code %d value %d", dev, type, code, value);
137
138         if (type != EV_LED)
139                 return -1;
140
141         newleds = (!!test_bit(LED_KANA,    dev->led) << 3) |
142                   (!!test_bit(LED_COMPOSE, dev->led) << 3) |
143                   (!!test_bit(LED_SCROLLL, dev->led) << 2) |
144                   (!!test_bit(LED_CAPSL,   dev->led) << 1) |
145                   (!!test_bit(LED_NUML,    dev->led));
146
147         if (session->leds == newleds)
148                 return 0;
149
150         session->leds = newleds;
151
152         if (!(skb = alloc_skb(3, GFP_ATOMIC))) {
153                 BT_ERR("Can't allocate memory for new frame");
154                 return -ENOMEM;
155         }
156
157         *skb_put(skb, 1) = HIDP_TRANS_DATA | HIDP_DATA_RTYPE_OUPUT;
158         *skb_put(skb, 1) = 0x01;
159         *skb_put(skb, 1) = newleds;
160
161         skb_queue_tail(&session->intr_transmit, skb);
162
163         hidp_schedule(session);
164
165         return 0;
166 }
167
168 static void hidp_input_report(struct hidp_session *session, struct sk_buff *skb)
169 {
170         struct input_dev *dev = session->input;
171         unsigned char *keys = session->keys;
172         unsigned char *udata = skb->data + 1;
173         signed char *sdata = skb->data + 1;
174         int i, size = skb->len - 1;
175
176         switch (skb->data[0]) {
177         case 0x01:      /* Keyboard report */
178                 for (i = 0; i < 8; i++)
179                         input_report_key(dev, hidp_keycode[i + 224], (udata[0] >> i) & 1);
180
181                 /* If all the key codes have been set to 0x01, it means
182                  * too many keys were pressed at the same time. */
183                 if (!memcmp(udata + 2, hidp_mkeyspat, 6))
184                         break;
185
186                 for (i = 2; i < 8; i++) {
187                         if (keys[i] > 3 && memscan(udata + 2, keys[i], 6) == udata + 8) {
188                                 if (hidp_keycode[keys[i]])
189                                         input_report_key(dev, hidp_keycode[keys[i]], 0);
190                                 else
191                                         BT_ERR("Unknown key (scancode %#x) released.", keys[i]);
192                         }
193
194                         if (udata[i] > 3 && memscan(keys + 2, udata[i], 6) == keys + 8) {
195                                 if (hidp_keycode[udata[i]])
196                                         input_report_key(dev, hidp_keycode[udata[i]], 1);
197                                 else
198                                         BT_ERR("Unknown key (scancode %#x) pressed.", udata[i]);
199                         }
200                 }
201
202                 memcpy(keys, udata, 8);
203                 break;
204
205         case 0x02:      /* Mouse report */
206                 input_report_key(dev, BTN_LEFT,   sdata[0] & 0x01);
207                 input_report_key(dev, BTN_RIGHT,  sdata[0] & 0x02);
208                 input_report_key(dev, BTN_MIDDLE, sdata[0] & 0x04);
209                 input_report_key(dev, BTN_SIDE,   sdata[0] & 0x08);
210                 input_report_key(dev, BTN_EXTRA,  sdata[0] & 0x10);
211
212                 input_report_rel(dev, REL_X, sdata[1]);
213                 input_report_rel(dev, REL_Y, sdata[2]);
214
215                 if (size > 3)
216                         input_report_rel(dev, REL_WHEEL, sdata[3]);
217                 break;
218         }
219
220         input_sync(dev);
221 }
222
223 static void hidp_idle_timeout(unsigned long arg)
224 {
225         struct hidp_session *session = (struct hidp_session *) arg;
226
227         atomic_inc(&session->terminate);
228         hidp_schedule(session);
229 }
230
231 static inline void hidp_set_timer(struct hidp_session *session)
232 {
233         if (session->idle_to > 0)
234                 mod_timer(&session->timer, jiffies + HZ * session->idle_to);
235 }
236
237 static inline void hidp_del_timer(struct hidp_session *session)
238 {
239         if (session->idle_to > 0)
240                 del_timer(&session->timer);
241 }
242
243 static int __hidp_send_ctrl_message(struct hidp_session *session,
244                         unsigned char hdr, unsigned char *data, int size)
245 {
246         struct sk_buff *skb;
247
248         BT_DBG("session %p data %p size %d", session, data, size);
249
250         if (!(skb = alloc_skb(size + 1, GFP_ATOMIC))) {
251                 BT_ERR("Can't allocate memory for new frame");
252                 return -ENOMEM;
253         }
254
255         *skb_put(skb, 1) = hdr;
256         if (data && size > 0)
257                 memcpy(skb_put(skb, size), data, size);
258
259         skb_queue_tail(&session->ctrl_transmit, skb);
260
261         return 0;
262 }
263
264 static int inline hidp_send_ctrl_message(struct hidp_session *session,
265                         unsigned char hdr, unsigned char *data, int size)
266 {
267         int err;
268
269         err = __hidp_send_ctrl_message(session, hdr, data, size);
270
271         hidp_schedule(session);
272
273         return err;
274 }
275
276 static inline void hidp_process_handshake(struct hidp_session *session, unsigned char param)
277 {
278         BT_DBG("session %p param 0x%02x", session, param);
279
280         switch (param) {
281         case HIDP_HSHK_SUCCESSFUL:
282                 /* FIXME: Call into SET_ GET_ handlers here */
283                 break;
284
285         case HIDP_HSHK_NOT_READY:
286         case HIDP_HSHK_ERR_INVALID_REPORT_ID:
287         case HIDP_HSHK_ERR_UNSUPPORTED_REQUEST:
288         case HIDP_HSHK_ERR_INVALID_PARAMETER:
289                 /* FIXME: Call into SET_ GET_ handlers here */
290                 break;
291
292         case HIDP_HSHK_ERR_UNKNOWN:
293                 break;
294
295         case HIDP_HSHK_ERR_FATAL:
296                 /* Device requests a reboot, as this is the only way this error
297                  * can be recovered. */
298                 __hidp_send_ctrl_message(session,
299                         HIDP_TRANS_HID_CONTROL | HIDP_CTRL_SOFT_RESET, NULL, 0);
300                 break;
301
302         default:
303                 __hidp_send_ctrl_message(session,
304                         HIDP_TRANS_HANDSHAKE | HIDP_HSHK_ERR_INVALID_PARAMETER, NULL, 0);
305                 break;
306         }
307 }
308
309 static inline void hidp_process_hid_control(struct hidp_session *session, unsigned char param)
310 {
311         BT_DBG("session %p param 0x%02x", session, param);
312
313         switch (param) {
314         case HIDP_CTRL_NOP:
315                 break;
316
317         case HIDP_CTRL_VIRTUAL_CABLE_UNPLUG:
318                 /* Flush the transmit queues */
319                 skb_queue_purge(&session->ctrl_transmit);
320                 skb_queue_purge(&session->intr_transmit);
321
322                 /* Kill session thread */
323                 atomic_inc(&session->terminate);
324                 break;
325
326         case HIDP_CTRL_HARD_RESET:
327         case HIDP_CTRL_SOFT_RESET:
328         case HIDP_CTRL_SUSPEND:
329         case HIDP_CTRL_EXIT_SUSPEND:
330                 /* FIXME: We have to parse these and return no error */
331                 break;
332
333         default:
334                 __hidp_send_ctrl_message(session,
335                         HIDP_TRANS_HANDSHAKE | HIDP_HSHK_ERR_INVALID_PARAMETER, NULL, 0);
336                 break;
337         }
338 }
339
340 static inline void hidp_process_data(struct hidp_session *session, struct sk_buff *skb, unsigned char param)
341 {
342         BT_DBG("session %p skb %p len %d param 0x%02x", session, skb, skb->len, param);
343
344         switch (param) {
345         case HIDP_DATA_RTYPE_INPUT:
346                 hidp_set_timer(session);
347
348                 if (session->input)
349                         hidp_input_report(session, skb);
350                 break;
351
352         case HIDP_DATA_RTYPE_OTHER:
353         case HIDP_DATA_RTYPE_OUPUT:
354         case HIDP_DATA_RTYPE_FEATURE:
355                 break;
356
357         default:
358                 __hidp_send_ctrl_message(session,
359                         HIDP_TRANS_HANDSHAKE | HIDP_HSHK_ERR_INVALID_PARAMETER, NULL, 0);
360         }
361 }
362
363 static inline void hidp_recv_ctrl_frame(struct hidp_session *session, struct sk_buff *skb)
364 {
365         unsigned char hdr, type, param;
366
367         BT_DBG("session %p skb %p len %d", session, skb, skb->len);
368
369         hdr = skb->data[0];
370         skb_pull(skb, 1);
371
372         type = hdr & HIDP_HEADER_TRANS_MASK;
373         param = hdr & HIDP_HEADER_PARAM_MASK;
374
375         switch (type) {
376         case HIDP_TRANS_HANDSHAKE:
377                 hidp_process_handshake(session, param);
378                 break;
379
380         case HIDP_TRANS_HID_CONTROL:
381                 hidp_process_hid_control(session, param);
382                 break;
383
384         case HIDP_TRANS_DATA:
385                 hidp_process_data(session, skb, param);
386                 break;
387
388         default:
389                 __hidp_send_ctrl_message(session,
390                         HIDP_TRANS_HANDSHAKE | HIDP_HSHK_ERR_UNSUPPORTED_REQUEST, NULL, 0);
391                 break;
392         }
393
394         kfree_skb(skb);
395 }
396
397 static inline void hidp_recv_intr_frame(struct hidp_session *session, struct sk_buff *skb)
398 {
399         unsigned char hdr;
400
401         BT_DBG("session %p skb %p len %d", session, skb, skb->len);
402
403         hdr = skb->data[0];
404         skb_pull(skb, 1);
405
406         if (hdr == (HIDP_TRANS_DATA | HIDP_DATA_RTYPE_INPUT)) {
407                 hidp_set_timer(session);
408                 if (session->input)
409                         hidp_input_report(session, skb);
410         } else {
411                 BT_DBG("Unsupported protocol header 0x%02x", hdr);
412         }
413
414         kfree_skb(skb);
415 }
416
417 static int hidp_send_frame(struct socket *sock, unsigned char *data, int len)
418 {
419         struct kvec iv = { data, len };
420         struct msghdr msg;
421
422         BT_DBG("sock %p data %p len %d", sock, data, len);
423
424         if (!len)
425                 return 0;
426
427         memset(&msg, 0, sizeof(msg));
428
429         return kernel_sendmsg(sock, &msg, &iv, 1, len);
430 }
431
432 static int hidp_process_transmit(struct hidp_session *session)
433 {
434         struct sk_buff *skb;
435
436         BT_DBG("session %p", session);
437
438         while ((skb = skb_dequeue(&session->ctrl_transmit))) {
439                 if (hidp_send_frame(session->ctrl_sock, skb->data, skb->len) < 0) {
440                         skb_queue_head(&session->ctrl_transmit, skb);
441                         break;
442                 }
443
444                 hidp_set_timer(session);
445                 kfree_skb(skb);
446         }
447
448         while ((skb = skb_dequeue(&session->intr_transmit))) {
449                 if (hidp_send_frame(session->intr_sock, skb->data, skb->len) < 0) {
450                         skb_queue_head(&session->intr_transmit, skb);
451                         break;
452                 }
453
454                 hidp_set_timer(session);
455                 kfree_skb(skb);
456         }
457
458         return skb_queue_len(&session->ctrl_transmit) +
459                                 skb_queue_len(&session->intr_transmit);
460 }
461
462 static int hidp_session(void *arg)
463 {
464         struct hidp_session *session = arg;
465         struct sock *ctrl_sk = session->ctrl_sock->sk;
466         struct sock *intr_sk = session->intr_sock->sk;
467         struct sk_buff *skb;
468         int vendor = 0x0000, product = 0x0000;
469         wait_queue_t ctrl_wait, intr_wait;
470
471         BT_DBG("session %p", session);
472
473         if (session->input) {
474                 vendor  = session->input->id.vendor;
475                 product = session->input->id.product;
476         }
477
478         daemonize("khidpd_%04x%04x", vendor, product);
479         set_user_nice(current, -15);
480         current->flags |= PF_NOFREEZE;
481
482         init_waitqueue_entry(&ctrl_wait, current);
483         init_waitqueue_entry(&intr_wait, current);
484         add_wait_queue(ctrl_sk->sk_sleep, &ctrl_wait);
485         add_wait_queue(intr_sk->sk_sleep, &intr_wait);
486         while (!atomic_read(&session->terminate)) {
487                 set_current_state(TASK_INTERRUPTIBLE);
488
489                 if (ctrl_sk->sk_state != BT_CONNECTED || intr_sk->sk_state != BT_CONNECTED)
490                         break;
491
492                 while ((skb = skb_dequeue(&ctrl_sk->sk_receive_queue))) {
493                         skb_orphan(skb);
494                         hidp_recv_ctrl_frame(session, skb);
495                 }
496
497                 while ((skb = skb_dequeue(&intr_sk->sk_receive_queue))) {
498                         skb_orphan(skb);
499                         hidp_recv_intr_frame(session, skb);
500                 }
501
502                 hidp_process_transmit(session);
503
504                 schedule();
505         }
506         set_current_state(TASK_RUNNING);
507         remove_wait_queue(intr_sk->sk_sleep, &intr_wait);
508         remove_wait_queue(ctrl_sk->sk_sleep, &ctrl_wait);
509
510         down_write(&hidp_session_sem);
511
512         hidp_del_timer(session);
513
514         if (intr_sk->sk_state != BT_CONNECTED)
515                 wait_event_timeout(*(ctrl_sk->sk_sleep), (ctrl_sk->sk_state == BT_CLOSED), HZ);
516
517         fput(session->ctrl_sock->file);
518
519         wait_event_timeout(*(intr_sk->sk_sleep), (intr_sk->sk_state == BT_CLOSED), HZ);
520
521         fput(session->intr_sock->file);
522
523         __hidp_unlink_session(session);
524
525         if (session->input) {
526                 input_unregister_device(session->input);
527                 kfree(session->input);
528         }
529
530         up_write(&hidp_session_sem);
531
532         kfree(session);
533         return 0;
534 }
535
536 static inline void hidp_setup_input(struct hidp_session *session, struct hidp_connadd_req *req)
537 {
538         struct input_dev *input = session->input;
539         int i;
540
541         input->private = session;
542
543         input->id.bustype = BUS_BLUETOOTH;
544         input->id.vendor  = req->vendor;
545         input->id.product = req->product;
546         input->id.version = req->version;
547
548         if (req->subclass & 0x40) {
549                 set_bit(EV_KEY, input->evbit);
550                 set_bit(EV_LED, input->evbit);
551                 set_bit(EV_REP, input->evbit);
552
553                 set_bit(LED_NUML,    input->ledbit);
554                 set_bit(LED_CAPSL,   input->ledbit);
555                 set_bit(LED_SCROLLL, input->ledbit);
556                 set_bit(LED_COMPOSE, input->ledbit);
557                 set_bit(LED_KANA,    input->ledbit);
558
559                 for (i = 0; i < sizeof(hidp_keycode); i++)
560                         set_bit(hidp_keycode[i], input->keybit);
561                 clear_bit(0, input->keybit);
562         }
563
564         if (req->subclass & 0x80) {
565                 input->evbit[0] = BIT(EV_KEY) | BIT(EV_REL);
566                 input->keybit[LONG(BTN_MOUSE)] = BIT(BTN_LEFT) | BIT(BTN_RIGHT) | BIT(BTN_MIDDLE);
567                 input->relbit[0] = BIT(REL_X) | BIT(REL_Y);
568                 input->keybit[LONG(BTN_MOUSE)] |= BIT(BTN_SIDE) | BIT(BTN_EXTRA);
569                 input->relbit[0] |= BIT(REL_WHEEL);
570         }
571
572         input->event = hidp_input_event;
573
574         input_register_device(input);
575 }
576
577 int hidp_add_connection(struct hidp_connadd_req *req, struct socket *ctrl_sock, struct socket *intr_sock)
578 {
579         struct hidp_session *session, *s;
580         int err;
581
582         BT_DBG("");
583
584         if (bacmp(&bt_sk(ctrl_sock->sk)->src, &bt_sk(intr_sock->sk)->src) ||
585                         bacmp(&bt_sk(ctrl_sock->sk)->dst, &bt_sk(intr_sock->sk)->dst))
586                 return -ENOTUNIQ;
587
588         session = kmalloc(sizeof(struct hidp_session), GFP_KERNEL);
589         if (!session) 
590                 return -ENOMEM;
591         memset(session, 0, sizeof(struct hidp_session));
592
593         session->input = kmalloc(sizeof(struct input_dev), GFP_KERNEL);
594         if (!session->input) {
595                 kfree(session);
596                 return -ENOMEM;
597         }
598         memset(session->input, 0, sizeof(struct input_dev));
599
600         down_write(&hidp_session_sem);
601
602         s = __hidp_get_session(&bt_sk(ctrl_sock->sk)->dst);
603         if (s && s->state == BT_CONNECTED) {
604                 err = -EEXIST;
605                 goto failed;
606         }
607
608         bacpy(&session->bdaddr, &bt_sk(ctrl_sock->sk)->dst);
609
610         session->ctrl_mtu = min_t(uint, l2cap_pi(ctrl_sock->sk)->omtu, l2cap_pi(ctrl_sock->sk)->imtu);
611         session->intr_mtu = min_t(uint, l2cap_pi(intr_sock->sk)->omtu, l2cap_pi(intr_sock->sk)->imtu);
612
613         BT_DBG("ctrl mtu %d intr mtu %d", session->ctrl_mtu, session->intr_mtu);
614
615         session->ctrl_sock = ctrl_sock;
616         session->intr_sock = intr_sock;
617         session->state     = BT_CONNECTED;
618
619         init_timer(&session->timer);
620
621         session->timer.function = hidp_idle_timeout;
622         session->timer.data     = (unsigned long) session;
623
624         skb_queue_head_init(&session->ctrl_transmit);
625         skb_queue_head_init(&session->intr_transmit);
626
627         session->flags   = req->flags & (1 << HIDP_BLUETOOTH_VENDOR_ID);
628         session->idle_to = req->idle_to;
629
630         if (session->input)
631                 hidp_setup_input(session, req);
632
633         __hidp_link_session(session);
634
635         hidp_set_timer(session);
636
637         err = kernel_thread(hidp_session, session, CLONE_KERNEL);
638         if (err < 0)
639                 goto unlink;
640
641         if (session->input) {
642                 hidp_send_ctrl_message(session,
643                         HIDP_TRANS_SET_PROTOCOL | HIDP_PROTO_BOOT, NULL, 0);
644                 session->flags |= (1 << HIDP_BOOT_PROTOCOL_MODE);
645
646                 session->leds = 0xff;
647                 hidp_input_event(session->input, EV_LED, 0, 0);
648         }
649
650         up_write(&hidp_session_sem);
651         return 0;
652
653 unlink:
654         hidp_del_timer(session);
655
656         __hidp_unlink_session(session);
657
658         if (session->input)
659                 input_unregister_device(session->input);
660
661 failed:
662         up_write(&hidp_session_sem);
663
664         if (session->input)
665                 kfree(session->input);
666
667         kfree(session);
668         return err;
669 }
670
671 int hidp_del_connection(struct hidp_conndel_req *req)
672 {
673         struct hidp_session *session;
674         int err = 0;
675
676         BT_DBG("");
677
678         down_read(&hidp_session_sem);
679
680         session = __hidp_get_session(&req->bdaddr);
681         if (session) {
682                 if (req->flags & (1 << HIDP_VIRTUAL_CABLE_UNPLUG)) {
683                         hidp_send_ctrl_message(session,
684                                 HIDP_TRANS_HID_CONTROL | HIDP_CTRL_VIRTUAL_CABLE_UNPLUG, NULL, 0);
685                 } else {
686                         /* Flush the transmit queues */
687                         skb_queue_purge(&session->ctrl_transmit);
688                         skb_queue_purge(&session->intr_transmit);
689
690                         /* Kill session thread */
691                         atomic_inc(&session->terminate);
692                         hidp_schedule(session);
693                 }
694         } else
695                 err = -ENOENT;
696
697         up_read(&hidp_session_sem);
698         return err;
699 }
700
701 int hidp_get_connlist(struct hidp_connlist_req *req)
702 {
703         struct list_head *p;
704         int err = 0, n = 0;
705
706         BT_DBG("");
707
708         down_read(&hidp_session_sem);
709
710         list_for_each(p, &hidp_session_list) {
711                 struct hidp_session *session;
712                 struct hidp_conninfo ci;
713
714                 session = list_entry(p, struct hidp_session, list);
715
716                 __hidp_copy_session(session, &ci);
717
718                 if (copy_to_user(req->ci, &ci, sizeof(ci))) {
719                         err = -EFAULT;
720                         break;
721                 }
722
723                 if (++n >= req->cnum)
724                         break;
725
726                 req->ci++;
727         }
728         req->cnum = n;
729
730         up_read(&hidp_session_sem);
731         return err;
732 }
733
734 int hidp_get_conninfo(struct hidp_conninfo *ci)
735 {
736         struct hidp_session *session;
737         int err = 0;
738
739         down_read(&hidp_session_sem);
740
741         session = __hidp_get_session(&ci->bdaddr);
742         if (session)
743                 __hidp_copy_session(session, ci);
744         else
745                 err = -ENOENT;
746
747         up_read(&hidp_session_sem);
748         return err;
749 }
750
751 static int __init hidp_init(void)
752 {
753         l2cap_load();
754
755         BT_INFO("HIDP (Human Interface Emulation) ver %s", VERSION);
756
757         return hidp_init_sockets();
758 }
759
760 static void __exit hidp_exit(void)
761 {
762         hidp_cleanup_sockets();
763 }
764
765 module_init(hidp_init);
766 module_exit(hidp_exit);
767
768 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
769 MODULE_DESCRIPTION("Bluetooth HIDP ver " VERSION);
770 MODULE_VERSION(VERSION);
771 MODULE_LICENSE("GPL");
772 MODULE_ALIAS("bt-proto-6");