HID: make a bus from hid code
[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/module.h>
24
25 #include <linux/types.h>
26 #include <linux/errno.h>
27 #include <linux/kernel.h>
28 #include <linux/sched.h>
29 #include <linux/slab.h>
30 #include <linux/poll.h>
31 #include <linux/freezer.h>
32 #include <linux/fcntl.h>
33 #include <linux/skbuff.h>
34 #include <linux/socket.h>
35 #include <linux/ioctl.h>
36 #include <linux/file.h>
37 #include <linux/init.h>
38 #include <linux/wait.h>
39 #include <net/sock.h>
40
41 #include <linux/input.h>
42 #include <linux/hid.h>
43
44 #include <net/bluetooth/bluetooth.h>
45 #include <net/bluetooth/hci_core.h>
46 #include <net/bluetooth/l2cap.h>
47
48 #include "hidp.h"
49
50 #ifndef CONFIG_BT_HIDP_DEBUG
51 #undef  BT_DBG
52 #define BT_DBG(D...)
53 #endif
54
55 #define VERSION "1.2"
56
57 static DECLARE_RWSEM(hidp_session_sem);
58 static LIST_HEAD(hidp_session_list);
59
60 static unsigned char hidp_keycode[256] = {
61           0,  0,  0,  0, 30, 48, 46, 32, 18, 33, 34, 35, 23, 36, 37, 38,
62          50, 49, 24, 25, 16, 19, 31, 20, 22, 47, 17, 45, 21, 44,  2,  3,
63           4,  5,  6,  7,  8,  9, 10, 11, 28,  1, 14, 15, 57, 12, 13, 26,
64          27, 43, 43, 39, 40, 41, 51, 52, 53, 58, 59, 60, 61, 62, 63, 64,
65          65, 66, 67, 68, 87, 88, 99, 70,119,110,102,104,111,107,109,106,
66         105,108,103, 69, 98, 55, 74, 78, 96, 79, 80, 81, 75, 76, 77, 71,
67          72, 73, 82, 83, 86,127,116,117,183,184,185,186,187,188,189,190,
68         191,192,193,194,134,138,130,132,128,129,131,137,133,135,136,113,
69         115,114,  0,  0,  0,121,  0, 89, 93,124, 92, 94, 95,  0,  0,  0,
70         122,123, 90, 91, 85,  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           0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
75          29, 42, 56,125, 97, 54,100,126,164,166,165,163,161,115,114,113,
76         150,158,159,128,136,177,178,176,142,152,173,140
77 };
78
79 static unsigned char hidp_mkeyspat[] = { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 };
80
81 static struct hidp_session *__hidp_get_session(bdaddr_t *bdaddr)
82 {
83         struct hidp_session *session;
84         struct list_head *p;
85
86         BT_DBG("");
87
88         list_for_each(p, &hidp_session_list) {
89                 session = list_entry(p, struct hidp_session, list);
90                 if (!bacmp(bdaddr, &session->bdaddr))
91                         return session;
92         }
93         return NULL;
94 }
95
96 static void __hidp_link_session(struct hidp_session *session)
97 {
98         __module_get(THIS_MODULE);
99         list_add(&session->list, &hidp_session_list);
100 }
101
102 static void __hidp_unlink_session(struct hidp_session *session)
103 {
104         list_del(&session->list);
105         module_put(THIS_MODULE);
106 }
107
108 static void __hidp_copy_session(struct hidp_session *session, struct hidp_conninfo *ci)
109 {
110         bacpy(&ci->bdaddr, &session->bdaddr);
111
112         ci->flags = session->flags;
113         ci->state = session->state;
114
115         ci->vendor  = 0x0000;
116         ci->product = 0x0000;
117         ci->version = 0x0000;
118         memset(ci->name, 0, 128);
119
120         if (session->input) {
121                 ci->vendor  = session->input->id.vendor;
122                 ci->product = session->input->id.product;
123                 ci->version = session->input->id.version;
124                 if (session->input->name)
125                         strncpy(ci->name, session->input->name, 128);
126                 else
127                         strncpy(ci->name, "HID Boot Device", 128);
128         }
129
130         if (session->hid) {
131                 ci->vendor  = session->hid->vendor;
132                 ci->product = session->hid->product;
133                 ci->version = session->hid->version;
134                 strncpy(ci->name, session->hid->name, 128);
135         }
136 }
137
138 static int hidp_queue_event(struct hidp_session *session, struct input_dev *dev,
139                                 unsigned int type, unsigned int code, int value)
140 {
141         unsigned char newleds;
142         struct sk_buff *skb;
143
144         BT_DBG("session %p type %d code %d value %d", session, type, code, value);
145
146         if (type != EV_LED)
147                 return -1;
148
149         newleds = (!!test_bit(LED_KANA,    dev->led) << 3) |
150                   (!!test_bit(LED_COMPOSE, dev->led) << 3) |
151                   (!!test_bit(LED_SCROLLL, dev->led) << 2) |
152                   (!!test_bit(LED_CAPSL,   dev->led) << 1) |
153                   (!!test_bit(LED_NUML,    dev->led));
154
155         if (session->leds == newleds)
156                 return 0;
157
158         session->leds = newleds;
159
160         if (!(skb = alloc_skb(3, GFP_ATOMIC))) {
161                 BT_ERR("Can't allocate memory for new frame");
162                 return -ENOMEM;
163         }
164
165         *skb_put(skb, 1) = HIDP_TRANS_DATA | HIDP_DATA_RTYPE_OUPUT;
166         *skb_put(skb, 1) = 0x01;
167         *skb_put(skb, 1) = newleds;
168
169         skb_queue_tail(&session->intr_transmit, skb);
170
171         hidp_schedule(session);
172
173         return 0;
174 }
175
176 static int hidp_hidinput_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
177 {
178         struct hid_device *hid = input_get_drvdata(dev);
179         struct hidp_session *session = hid->driver_data;
180
181         return hidp_queue_event(session, dev, type, code, value);
182 }
183
184 static int hidp_input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
185 {
186         struct hidp_session *session = input_get_drvdata(dev);
187
188         return hidp_queue_event(session, dev, type, code, value);
189 }
190
191 static void hidp_input_report(struct hidp_session *session, struct sk_buff *skb)
192 {
193         struct input_dev *dev = session->input;
194         unsigned char *keys = session->keys;
195         unsigned char *udata = skb->data + 1;
196         signed char *sdata = skb->data + 1;
197         int i, size = skb->len - 1;
198
199         switch (skb->data[0]) {
200         case 0x01:      /* Keyboard report */
201                 for (i = 0; i < 8; i++)
202                         input_report_key(dev, hidp_keycode[i + 224], (udata[0] >> i) & 1);
203
204                 /* If all the key codes have been set to 0x01, it means
205                  * too many keys were pressed at the same time. */
206                 if (!memcmp(udata + 2, hidp_mkeyspat, 6))
207                         break;
208
209                 for (i = 2; i < 8; i++) {
210                         if (keys[i] > 3 && memscan(udata + 2, keys[i], 6) == udata + 8) {
211                                 if (hidp_keycode[keys[i]])
212                                         input_report_key(dev, hidp_keycode[keys[i]], 0);
213                                 else
214                                         BT_ERR("Unknown key (scancode %#x) released.", keys[i]);
215                         }
216
217                         if (udata[i] > 3 && memscan(keys + 2, udata[i], 6) == keys + 8) {
218                                 if (hidp_keycode[udata[i]])
219                                         input_report_key(dev, hidp_keycode[udata[i]], 1);
220                                 else
221                                         BT_ERR("Unknown key (scancode %#x) pressed.", udata[i]);
222                         }
223                 }
224
225                 memcpy(keys, udata, 8);
226                 break;
227
228         case 0x02:      /* Mouse report */
229                 input_report_key(dev, BTN_LEFT,   sdata[0] & 0x01);
230                 input_report_key(dev, BTN_RIGHT,  sdata[0] & 0x02);
231                 input_report_key(dev, BTN_MIDDLE, sdata[0] & 0x04);
232                 input_report_key(dev, BTN_SIDE,   sdata[0] & 0x08);
233                 input_report_key(dev, BTN_EXTRA,  sdata[0] & 0x10);
234
235                 input_report_rel(dev, REL_X, sdata[1]);
236                 input_report_rel(dev, REL_Y, sdata[2]);
237
238                 if (size > 3)
239                         input_report_rel(dev, REL_WHEEL, sdata[3]);
240                 break;
241         }
242
243         input_sync(dev);
244 }
245
246 static int hidp_queue_report(struct hidp_session *session,
247                                 unsigned char *data, int size)
248 {
249         struct sk_buff *skb;
250
251         BT_DBG("session %p hid %p data %p size %d", session, session->hid, data, size);
252
253         if (!(skb = alloc_skb(size + 1, GFP_ATOMIC))) {
254                 BT_ERR("Can't allocate memory for new frame");
255                 return -ENOMEM;
256         }
257
258         *skb_put(skb, 1) = 0xa2;
259         if (size > 0)
260                 memcpy(skb_put(skb, size), data, size);
261
262         skb_queue_tail(&session->intr_transmit, skb);
263
264         hidp_schedule(session);
265
266         return 0;
267 }
268
269 static int hidp_send_report(struct hidp_session *session, struct hid_report *report)
270 {
271         unsigned char buf[32];
272         int rsize;
273
274         rsize = ((report->size - 1) >> 3) + 1 + (report->id > 0);
275         if (rsize > sizeof(buf))
276                 return -EIO;
277
278         hid_output_report(report, buf);
279
280         return hidp_queue_report(session, buf, rsize);
281 }
282
283 static void hidp_idle_timeout(unsigned long arg)
284 {
285         struct hidp_session *session = (struct hidp_session *) arg;
286
287         atomic_inc(&session->terminate);
288         hidp_schedule(session);
289 }
290
291 static void hidp_set_timer(struct hidp_session *session)
292 {
293         if (session->idle_to > 0)
294                 mod_timer(&session->timer, jiffies + HZ * session->idle_to);
295 }
296
297 static inline void hidp_del_timer(struct hidp_session *session)
298 {
299         if (session->idle_to > 0)
300                 del_timer(&session->timer);
301 }
302
303 static int __hidp_send_ctrl_message(struct hidp_session *session,
304                         unsigned char hdr, unsigned char *data, int size)
305 {
306         struct sk_buff *skb;
307
308         BT_DBG("session %p data %p size %d", session, data, size);
309
310         if (!(skb = alloc_skb(size + 1, GFP_ATOMIC))) {
311                 BT_ERR("Can't allocate memory for new frame");
312                 return -ENOMEM;
313         }
314
315         *skb_put(skb, 1) = hdr;
316         if (data && size > 0)
317                 memcpy(skb_put(skb, size), data, size);
318
319         skb_queue_tail(&session->ctrl_transmit, skb);
320
321         return 0;
322 }
323
324 static inline int hidp_send_ctrl_message(struct hidp_session *session,
325                         unsigned char hdr, unsigned char *data, int size)
326 {
327         int err;
328
329         err = __hidp_send_ctrl_message(session, hdr, data, size);
330
331         hidp_schedule(session);
332
333         return err;
334 }
335
336 static void hidp_process_handshake(struct hidp_session *session,
337                                         unsigned char param)
338 {
339         BT_DBG("session %p param 0x%02x", session, param);
340
341         switch (param) {
342         case HIDP_HSHK_SUCCESSFUL:
343                 /* FIXME: Call into SET_ GET_ handlers here */
344                 break;
345
346         case HIDP_HSHK_NOT_READY:
347         case HIDP_HSHK_ERR_INVALID_REPORT_ID:
348         case HIDP_HSHK_ERR_UNSUPPORTED_REQUEST:
349         case HIDP_HSHK_ERR_INVALID_PARAMETER:
350                 /* FIXME: Call into SET_ GET_ handlers here */
351                 break;
352
353         case HIDP_HSHK_ERR_UNKNOWN:
354                 break;
355
356         case HIDP_HSHK_ERR_FATAL:
357                 /* Device requests a reboot, as this is the only way this error
358                  * can be recovered. */
359                 __hidp_send_ctrl_message(session,
360                         HIDP_TRANS_HID_CONTROL | HIDP_CTRL_SOFT_RESET, NULL, 0);
361                 break;
362
363         default:
364                 __hidp_send_ctrl_message(session,
365                         HIDP_TRANS_HANDSHAKE | HIDP_HSHK_ERR_INVALID_PARAMETER, NULL, 0);
366                 break;
367         }
368 }
369
370 static void hidp_process_hid_control(struct hidp_session *session,
371                                         unsigned char param)
372 {
373         BT_DBG("session %p param 0x%02x", session, param);
374
375         if (param == HIDP_CTRL_VIRTUAL_CABLE_UNPLUG) {
376                 /* Flush the transmit queues */
377                 skb_queue_purge(&session->ctrl_transmit);
378                 skb_queue_purge(&session->intr_transmit);
379
380                 /* Kill session thread */
381                 atomic_inc(&session->terminate);
382         }
383 }
384
385 static void hidp_process_data(struct hidp_session *session, struct sk_buff *skb,
386                                 unsigned char param)
387 {
388         BT_DBG("session %p skb %p len %d param 0x%02x", session, skb, skb->len, param);
389
390         switch (param) {
391         case HIDP_DATA_RTYPE_INPUT:
392                 hidp_set_timer(session);
393
394                 if (session->input)
395                         hidp_input_report(session, skb);
396
397                 if (session->hid)
398                         hid_input_report(session->hid, HID_INPUT_REPORT, skb->data, skb->len, 0);
399
400                 break;
401
402         case HIDP_DATA_RTYPE_OTHER:
403         case HIDP_DATA_RTYPE_OUPUT:
404         case HIDP_DATA_RTYPE_FEATURE:
405                 break;
406
407         default:
408                 __hidp_send_ctrl_message(session,
409                         HIDP_TRANS_HANDSHAKE | HIDP_HSHK_ERR_INVALID_PARAMETER, NULL, 0);
410         }
411 }
412
413 static void hidp_recv_ctrl_frame(struct hidp_session *session,
414                                         struct sk_buff *skb)
415 {
416         unsigned char hdr, type, param;
417
418         BT_DBG("session %p skb %p len %d", session, skb, skb->len);
419
420         hdr = skb->data[0];
421         skb_pull(skb, 1);
422
423         type = hdr & HIDP_HEADER_TRANS_MASK;
424         param = hdr & HIDP_HEADER_PARAM_MASK;
425
426         switch (type) {
427         case HIDP_TRANS_HANDSHAKE:
428                 hidp_process_handshake(session, param);
429                 break;
430
431         case HIDP_TRANS_HID_CONTROL:
432                 hidp_process_hid_control(session, param);
433                 break;
434
435         case HIDP_TRANS_DATA:
436                 hidp_process_data(session, skb, param);
437                 break;
438
439         default:
440                 __hidp_send_ctrl_message(session,
441                         HIDP_TRANS_HANDSHAKE | HIDP_HSHK_ERR_UNSUPPORTED_REQUEST, NULL, 0);
442                 break;
443         }
444
445         kfree_skb(skb);
446 }
447
448 static void hidp_recv_intr_frame(struct hidp_session *session,
449                                 struct sk_buff *skb)
450 {
451         unsigned char hdr;
452
453         BT_DBG("session %p skb %p len %d", session, skb, skb->len);
454
455         hdr = skb->data[0];
456         skb_pull(skb, 1);
457
458         if (hdr == (HIDP_TRANS_DATA | HIDP_DATA_RTYPE_INPUT)) {
459                 hidp_set_timer(session);
460
461                 if (session->input)
462                         hidp_input_report(session, skb);
463
464                 if (session->hid) {
465                         hid_input_report(session->hid, HID_INPUT_REPORT, skb->data, skb->len, 1);
466                         BT_DBG("report len %d", skb->len);
467                 }
468         } else {
469                 BT_DBG("Unsupported protocol header 0x%02x", hdr);
470         }
471
472         kfree_skb(skb);
473 }
474
475 static int hidp_send_frame(struct socket *sock, unsigned char *data, int len)
476 {
477         struct kvec iv = { data, len };
478         struct msghdr msg;
479
480         BT_DBG("sock %p data %p len %d", sock, data, len);
481
482         if (!len)
483                 return 0;
484
485         memset(&msg, 0, sizeof(msg));
486
487         return kernel_sendmsg(sock, &msg, &iv, 1, len);
488 }
489
490 static void hidp_process_transmit(struct hidp_session *session)
491 {
492         struct sk_buff *skb;
493
494         BT_DBG("session %p", session);
495
496         while ((skb = skb_dequeue(&session->ctrl_transmit))) {
497                 if (hidp_send_frame(session->ctrl_sock, skb->data, skb->len) < 0) {
498                         skb_queue_head(&session->ctrl_transmit, skb);
499                         break;
500                 }
501
502                 hidp_set_timer(session);
503                 kfree_skb(skb);
504         }
505
506         while ((skb = skb_dequeue(&session->intr_transmit))) {
507                 if (hidp_send_frame(session->intr_sock, skb->data, skb->len) < 0) {
508                         skb_queue_head(&session->intr_transmit, skb);
509                         break;
510                 }
511
512                 hidp_set_timer(session);
513                 kfree_skb(skb);
514         }
515 }
516
517 static int hidp_session(void *arg)
518 {
519         struct hidp_session *session = arg;
520         struct sock *ctrl_sk = session->ctrl_sock->sk;
521         struct sock *intr_sk = session->intr_sock->sk;
522         struct sk_buff *skb;
523         int vendor = 0x0000, product = 0x0000;
524         wait_queue_t ctrl_wait, intr_wait;
525
526         BT_DBG("session %p", session);
527
528         if (session->input) {
529                 vendor  = session->input->id.vendor;
530                 product = session->input->id.product;
531         }
532
533         if (session->hid) {
534                 vendor  = session->hid->vendor;
535                 product = session->hid->product;
536         }
537
538         daemonize("khidpd_%04x%04x", vendor, product);
539         set_user_nice(current, -15);
540
541         init_waitqueue_entry(&ctrl_wait, current);
542         init_waitqueue_entry(&intr_wait, current);
543         add_wait_queue(ctrl_sk->sk_sleep, &ctrl_wait);
544         add_wait_queue(intr_sk->sk_sleep, &intr_wait);
545         while (!atomic_read(&session->terminate)) {
546                 set_current_state(TASK_INTERRUPTIBLE);
547
548                 if (ctrl_sk->sk_state != BT_CONNECTED || intr_sk->sk_state != BT_CONNECTED)
549                         break;
550
551                 while ((skb = skb_dequeue(&ctrl_sk->sk_receive_queue))) {
552                         skb_orphan(skb);
553                         hidp_recv_ctrl_frame(session, skb);
554                 }
555
556                 while ((skb = skb_dequeue(&intr_sk->sk_receive_queue))) {
557                         skb_orphan(skb);
558                         hidp_recv_intr_frame(session, skb);
559                 }
560
561                 hidp_process_transmit(session);
562
563                 schedule();
564         }
565         set_current_state(TASK_RUNNING);
566         remove_wait_queue(intr_sk->sk_sleep, &intr_wait);
567         remove_wait_queue(ctrl_sk->sk_sleep, &ctrl_wait);
568
569         down_write(&hidp_session_sem);
570
571         hidp_del_timer(session);
572
573         if (session->input) {
574                 input_unregister_device(session->input);
575                 session->input = NULL;
576         }
577
578         if (session->hid) {
579                 if (session->hid->claimed & HID_CLAIMED_INPUT)
580                         hidinput_disconnect(session->hid);
581                 hid_destroy_device(session->hid);
582         }
583
584         /* Wakeup user-space polling for socket errors */
585         session->intr_sock->sk->sk_err = EUNATCH;
586         session->ctrl_sock->sk->sk_err = EUNATCH;
587
588         hidp_schedule(session);
589
590         fput(session->intr_sock->file);
591
592         wait_event_timeout(*(ctrl_sk->sk_sleep),
593                 (ctrl_sk->sk_state == BT_CLOSED), msecs_to_jiffies(500));
594
595         fput(session->ctrl_sock->file);
596
597         __hidp_unlink_session(session);
598
599         up_write(&hidp_session_sem);
600
601         kfree(session);
602         return 0;
603 }
604
605 static struct device *hidp_get_device(struct hidp_session *session)
606 {
607         bdaddr_t *src = &bt_sk(session->ctrl_sock->sk)->src;
608         bdaddr_t *dst = &bt_sk(session->ctrl_sock->sk)->dst;
609         struct hci_dev *hdev;
610         struct hci_conn *conn;
611
612         hdev = hci_get_route(dst, src);
613         if (!hdev)
614                 return NULL;
615
616         conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, dst);
617
618         hci_dev_put(hdev);
619
620         return conn ? &conn->dev : NULL;
621 }
622
623 static int hidp_setup_input(struct hidp_session *session,
624                                 struct hidp_connadd_req *req)
625 {
626         struct input_dev *input = session->input;
627         int i;
628
629         input_set_drvdata(input, session);
630
631         input->name = "Bluetooth HID Boot Protocol Device";
632
633         input->id.bustype = BUS_BLUETOOTH;
634         input->id.vendor  = req->vendor;
635         input->id.product = req->product;
636         input->id.version = req->version;
637
638         if (req->subclass & 0x40) {
639                 set_bit(EV_KEY, input->evbit);
640                 set_bit(EV_LED, input->evbit);
641                 set_bit(EV_REP, input->evbit);
642
643                 set_bit(LED_NUML,    input->ledbit);
644                 set_bit(LED_CAPSL,   input->ledbit);
645                 set_bit(LED_SCROLLL, input->ledbit);
646                 set_bit(LED_COMPOSE, input->ledbit);
647                 set_bit(LED_KANA,    input->ledbit);
648
649                 for (i = 0; i < sizeof(hidp_keycode); i++)
650                         set_bit(hidp_keycode[i], input->keybit);
651                 clear_bit(0, input->keybit);
652         }
653
654         if (req->subclass & 0x80) {
655                 input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL);
656                 input->keybit[BIT_WORD(BTN_MOUSE)] = BIT_MASK(BTN_LEFT) |
657                         BIT_MASK(BTN_RIGHT) | BIT_MASK(BTN_MIDDLE);
658                 input->relbit[0] = BIT_MASK(REL_X) | BIT_MASK(REL_Y);
659                 input->keybit[BIT_WORD(BTN_MOUSE)] |= BIT_MASK(BTN_SIDE) |
660                         BIT_MASK(BTN_EXTRA);
661                 input->relbit[0] |= BIT_MASK(REL_WHEEL);
662         }
663
664         input->dev.parent = hidp_get_device(session);
665
666         input->event = hidp_input_event;
667
668         return input_register_device(input);
669 }
670
671 static int hidp_open(struct hid_device *hid)
672 {
673         return 0;
674 }
675
676 static void hidp_close(struct hid_device *hid)
677 {
678 }
679
680 static const struct {
681         __u16 idVendor;
682         __u16 idProduct;
683         unsigned quirks;
684 } hidp_blacklist[] = {
685         /* Apple wireless Mighty Mouse */
686         { 0x05ac, 0x030c, HID_QUIRK_MIGHTYMOUSE | HID_QUIRK_INVERT_HWHEEL },
687
688         { }     /* Terminating entry */
689 };
690
691 static void hidp_setup_quirks(struct hid_device *hid)
692 {
693         unsigned int n;
694
695         for (n = 0; hidp_blacklist[n].idVendor; n++)
696                 if (hidp_blacklist[n].idVendor == le16_to_cpu(hid->vendor) &&
697                                 hidp_blacklist[n].idProduct == le16_to_cpu(hid->product))
698                         hid->quirks = hidp_blacklist[n].quirks;
699 }
700
701 static int hidp_setup_hid(struct hidp_session *session,
702                                 struct hidp_connadd_req *req)
703 {
704         struct hid_device *hid = session->hid;
705         struct hid_report *report;
706         bdaddr_t src, dst;
707         int ret;
708
709         baswap(&src, &bt_sk(session->ctrl_sock->sk)->src);
710         baswap(&dst, &bt_sk(session->ctrl_sock->sk)->dst);
711
712         hid->driver_data = session;
713
714         hid->country = req->country;
715
716         hid->bus     = BUS_BLUETOOTH;
717         hid->vendor  = req->vendor;
718         hid->product = req->product;
719         hid->version = req->version;
720
721         strncpy(hid->name, req->name, 128);
722         strncpy(hid->phys, batostr(&src), 64);
723         strncpy(hid->uniq, batostr(&dst), 64);
724
725         hid->dev.parent = hidp_get_device(session);
726
727         hid->hid_open  = hidp_open;
728         hid->hid_close = hidp_close;
729
730         hid->hidinput_input_event = hidp_hidinput_event;
731
732         hidp_setup_quirks(hid);
733
734         list_for_each_entry(report, &hid->report_enum[HID_INPUT_REPORT].report_list, list)
735                 hidp_send_report(session, report);
736
737         list_for_each_entry(report, &hid->report_enum[HID_FEATURE_REPORT].report_list, list)
738                 hidp_send_report(session, report);
739
740         if (hidinput_connect(hid) == 0)
741                 hid->claimed |= HID_CLAIMED_INPUT;
742
743         ret = hid_add_device(hid);
744         if (ret) {
745                 if (hid->claimed & HID_CLAIMED_INPUT)
746                         hidinput_disconnect(hid);
747                 skb_queue_purge(&session->intr_transmit);
748         }
749
750         return ret;
751 }
752
753 int hidp_add_connection(struct hidp_connadd_req *req, struct socket *ctrl_sock, struct socket *intr_sock)
754 {
755         struct hidp_session *session, *s;
756         int err;
757
758         BT_DBG("");
759
760         if (bacmp(&bt_sk(ctrl_sock->sk)->src, &bt_sk(intr_sock->sk)->src) ||
761                         bacmp(&bt_sk(ctrl_sock->sk)->dst, &bt_sk(intr_sock->sk)->dst))
762                 return -ENOTUNIQ;
763
764         session = kzalloc(sizeof(struct hidp_session), GFP_KERNEL);
765         if (!session)
766                 return -ENOMEM;
767
768         BT_DBG("rd_data %p rd_size %d", req->rd_data, req->rd_size);
769
770         if (req->rd_size > 0) {
771                 unsigned char *buf = kmalloc(req->rd_size, GFP_KERNEL);
772
773                 if (!buf) {
774                         kfree(session);
775                         return -ENOMEM;
776                 }
777
778                 if (copy_from_user(buf, req->rd_data, req->rd_size)) {
779                         kfree(buf);
780                         kfree(session);
781                         return -EFAULT;
782                 }
783
784                 session->hid = hid_allocate_device();
785                 if (IS_ERR(session->hid)) {
786                         kfree(buf);
787                         kfree(session);
788                         return PTR_ERR(session->hid);
789                 }
790
791                 err = hid_parse_report(session->hid, buf, req->rd_size);
792
793                 kfree(buf);
794
795                 if (err) {
796                         hid_destroy_device(session->hid);
797                         kfree(session);
798                         return -EINVAL;
799                 }
800         }
801
802         if (!session->hid) {
803                 session->input = input_allocate_device();
804                 if (!session->input) {
805                         kfree(session);
806                         return -ENOMEM;
807                 }
808         }
809
810         down_write(&hidp_session_sem);
811
812         s = __hidp_get_session(&bt_sk(ctrl_sock->sk)->dst);
813         if (s && s->state == BT_CONNECTED) {
814                 err = -EEXIST;
815                 goto failed;
816         }
817
818         bacpy(&session->bdaddr, &bt_sk(ctrl_sock->sk)->dst);
819
820         session->ctrl_mtu = min_t(uint, l2cap_pi(ctrl_sock->sk)->omtu, l2cap_pi(ctrl_sock->sk)->imtu);
821         session->intr_mtu = min_t(uint, l2cap_pi(intr_sock->sk)->omtu, l2cap_pi(intr_sock->sk)->imtu);
822
823         BT_DBG("ctrl mtu %d intr mtu %d", session->ctrl_mtu, session->intr_mtu);
824
825         session->ctrl_sock = ctrl_sock;
826         session->intr_sock = intr_sock;
827         session->state     = BT_CONNECTED;
828
829         setup_timer(&session->timer, hidp_idle_timeout, (unsigned long)session);
830
831         skb_queue_head_init(&session->ctrl_transmit);
832         skb_queue_head_init(&session->intr_transmit);
833
834         session->flags   = req->flags & (1 << HIDP_BLUETOOTH_VENDOR_ID);
835         session->idle_to = req->idle_to;
836
837         if (session->input) {
838                 err = hidp_setup_input(session, req);
839                 if (err < 0)
840                         goto failed;
841         }
842
843         if (session->hid) {
844                 err = hidp_setup_hid(session, req);
845                 if (err)
846                         goto failed;
847         }
848
849         __hidp_link_session(session);
850
851         hidp_set_timer(session);
852
853         err = kernel_thread(hidp_session, session, CLONE_KERNEL);
854         if (err < 0)
855                 goto unlink;
856
857         if (session->input) {
858                 hidp_send_ctrl_message(session,
859                         HIDP_TRANS_SET_PROTOCOL | HIDP_PROTO_BOOT, NULL, 0);
860                 session->flags |= (1 << HIDP_BOOT_PROTOCOL_MODE);
861
862                 session->leds = 0xff;
863                 hidp_input_event(session->input, EV_LED, 0, 0);
864         }
865
866         up_write(&hidp_session_sem);
867         return 0;
868
869 unlink:
870         hidp_del_timer(session);
871
872         __hidp_unlink_session(session);
873
874         if (session->input) {
875                 input_unregister_device(session->input);
876                 session->input = NULL; /* don't try to free it here */
877         }
878
879 failed:
880         up_write(&hidp_session_sem);
881
882         if (session->hid)
883                 hid_destroy_device(session->hid);
884
885         input_free_device(session->input);
886         kfree(session);
887         return err;
888 }
889
890 int hidp_del_connection(struct hidp_conndel_req *req)
891 {
892         struct hidp_session *session;
893         int err = 0;
894
895         BT_DBG("");
896
897         down_read(&hidp_session_sem);
898
899         session = __hidp_get_session(&req->bdaddr);
900         if (session) {
901                 if (req->flags & (1 << HIDP_VIRTUAL_CABLE_UNPLUG)) {
902                         hidp_send_ctrl_message(session,
903                                 HIDP_TRANS_HID_CONTROL | HIDP_CTRL_VIRTUAL_CABLE_UNPLUG, NULL, 0);
904                 } else {
905                         /* Flush the transmit queues */
906                         skb_queue_purge(&session->ctrl_transmit);
907                         skb_queue_purge(&session->intr_transmit);
908
909                         /* Wakeup user-space polling for socket errors */
910                         session->intr_sock->sk->sk_err = EUNATCH;
911                         session->ctrl_sock->sk->sk_err = EUNATCH;
912
913                         /* Kill session thread */
914                         atomic_inc(&session->terminate);
915                         hidp_schedule(session);
916                 }
917         } else
918                 err = -ENOENT;
919
920         up_read(&hidp_session_sem);
921         return err;
922 }
923
924 int hidp_get_connlist(struct hidp_connlist_req *req)
925 {
926         struct list_head *p;
927         int err = 0, n = 0;
928
929         BT_DBG("");
930
931         down_read(&hidp_session_sem);
932
933         list_for_each(p, &hidp_session_list) {
934                 struct hidp_session *session;
935                 struct hidp_conninfo ci;
936
937                 session = list_entry(p, struct hidp_session, list);
938
939                 __hidp_copy_session(session, &ci);
940
941                 if (copy_to_user(req->ci, &ci, sizeof(ci))) {
942                         err = -EFAULT;
943                         break;
944                 }
945
946                 if (++n >= req->cnum)
947                         break;
948
949                 req->ci++;
950         }
951         req->cnum = n;
952
953         up_read(&hidp_session_sem);
954         return err;
955 }
956
957 int hidp_get_conninfo(struct hidp_conninfo *ci)
958 {
959         struct hidp_session *session;
960         int err = 0;
961
962         down_read(&hidp_session_sem);
963
964         session = __hidp_get_session(&ci->bdaddr);
965         if (session)
966                 __hidp_copy_session(session, ci);
967         else
968                 err = -ENOENT;
969
970         up_read(&hidp_session_sem);
971         return err;
972 }
973
974 static const struct hid_device_id hidp_table[] = {
975         { HID_BLUETOOTH_DEVICE(HID_ANY_ID, HID_ANY_ID) },
976         { }
977 };
978
979 static struct hid_driver hidp_driver = {
980         .name = "generic-bluetooth",
981         .id_table = hidp_table,
982 };
983
984 static int __init hidp_init(void)
985 {
986         int ret;
987
988         l2cap_load();
989
990         BT_INFO("HIDP (Human Interface Emulation) ver %s", VERSION);
991
992         ret = hid_register_driver(&hidp_driver);
993         if (ret)
994                 goto err;
995
996         ret = hidp_init_sockets();
997         if (ret)
998                 goto err_drv;
999
1000         return 0;
1001 err_drv:
1002         hid_unregister_driver(&hidp_driver);
1003 err:
1004         return ret;
1005 }
1006
1007 static void __exit hidp_exit(void)
1008 {
1009         hidp_cleanup_sockets();
1010         hid_unregister_driver(&hidp_driver);
1011 }
1012
1013 module_init(hidp_init);
1014 module_exit(hidp_exit);
1015
1016 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
1017 MODULE_DESCRIPTION("Bluetooth HIDP ver " VERSION);
1018 MODULE_VERSION(VERSION);
1019 MODULE_LICENSE("GPL");
1020 MODULE_ALIAS("bt-proto-6");