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