?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
sg_last() should use unsigned loop index variable
[linux-2.6/pdupreez.git] / net / bluetooth / hci_conn.c
blob9483320f6dad01e967e219297ff798c5d1a29af0
1 /*
2 BlueZ - Bluetooth protocol stack for Linux
3 Copyright (C) 2000-2001 Qualcomm Incorporated
4
5 Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License version 2 as
9 published by the Free Software Foundation;
10
11 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
12 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
13 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
14 IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
15 CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
16 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
17 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
18 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19
20 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
21 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
22 SOFTWARE IS DISCLAIMED.
23 */
24
25 /* Bluetooth HCI connection handling. */
26
27 #include <linux/module.h>
28
29 #include <linux/types.h>
30 #include <linux/errno.h>
31 #include <linux/kernel.h>
32 #include <linux/slab.h>
33 #include <linux/poll.h>
34 #include <linux/fcntl.h>
35 #include <linux/init.h>
36 #include <linux/skbuff.h>
37 #include <linux/interrupt.h>
38 #include <linux/notifier.h>
39 #include <net/sock.h>
40
41 #include <asm/system.h>
42 #include <asm/uaccess.h>
43 #include <asm/unaligned.h>
44
45 #include <net/bluetooth/bluetooth.h>
46 #include <net/bluetooth/hci_core.h>
47
48 #ifndef CONFIG_BT_HCI_CORE_DEBUG
49 #undef BT_DBG
50 #define BT_DBG(D...)
51 #endif
52
53 void hci_acl_connect(struct hci_conn *conn)
54 {
55 struct hci_dev *hdev = conn->hdev;
56 struct inquiry_entry *ie;
57 struct hci_cp_create_conn cp;
58
59 BT_DBG("%p", conn);
60
61 conn->state = BT_CONNECT;
62 conn->out = 1;
63 conn->link_mode = HCI_LM_MASTER;
64
65 conn->attempt++;
66
67 memset(&cp, 0, sizeof(cp));
68 bacpy(&cp.bdaddr, &conn->dst);
69 cp.pscan_rep_mode = 0x02;
70
71 if ((ie = hci_inquiry_cache_lookup(hdev, &conn->dst)) &&
72 inquiry_entry_age(ie) <= INQUIRY_ENTRY_AGE_MAX) {
73 cp.pscan_rep_mode = ie->data.pscan_rep_mode;
74 cp.pscan_mode = ie->data.pscan_mode;
75 cp.clock_offset = ie->data.clock_offset | cpu_to_le16(0x8000);
76 memcpy(conn->dev_class, ie->data.dev_class, 3);
77 }
78
79 cp.pkt_type = cpu_to_le16(hdev->pkt_type & ACL_PTYPE_MASK);
80 if (lmp_rswitch_capable(hdev) && !(hdev->link_mode & HCI_LM_MASTER))
81 cp.role_switch = 0x01;
82 else
83 cp.role_switch = 0x00;
84
85 hci_send_cmd(hdev, HCI_OP_CREATE_CONN, sizeof(cp), &cp);
86 }
87
88 static void hci_acl_connect_cancel(struct hci_conn *conn)
89 {
90 struct hci_cp_create_conn_cancel cp;
91
92 BT_DBG("%p", conn);
93
94 if (conn->hdev->hci_ver < 2)
95 return;
96
97 bacpy(&cp.bdaddr, &conn->dst);
98 hci_send_cmd(conn->hdev, HCI_OP_CREATE_CONN_CANCEL, sizeof(cp), &cp);
99 }
100
101 void hci_acl_disconn(struct hci_conn *conn, __u8 reason)
102 {
103 struct hci_cp_disconnect cp;
104
105 BT_DBG("%p", conn);
106
107 conn->state = BT_DISCONN;
108
109 cp.handle = cpu_to_le16(conn->handle);
110 cp.reason = reason;
111 hci_send_cmd(conn->hdev, HCI_OP_DISCONNECT, sizeof(cp), &cp);
112 }
113
114 void hci_add_sco(struct hci_conn *conn, __u16 handle)
115 {
116 struct hci_dev *hdev = conn->hdev;
117 struct hci_cp_add_sco cp;
118
119 BT_DBG("%p", conn);
120
121 conn->state = BT_CONNECT;
122 conn->out = 1;
123
124 cp.handle = cpu_to_le16(handle);
125 cp.pkt_type = cpu_to_le16(hdev->pkt_type & SCO_PTYPE_MASK);
126
127 hci_send_cmd(hdev, HCI_OP_ADD_SCO, sizeof(cp), &cp);
128 }
129
130 void hci_setup_sync(struct hci_conn *conn, __u16 handle)
131 {
132 struct hci_dev *hdev = conn->hdev;
133 struct hci_cp_setup_sync_conn cp;
134
135 BT_DBG("%p", conn);
136
137 conn->state = BT_CONNECT;
138 conn->out = 1;
139
140 cp.handle = cpu_to_le16(handle);
141 cp.pkt_type = cpu_to_le16(hdev->esco_type);
142
143 cp.tx_bandwidth = cpu_to_le32(0x00001f40);
144 cp.rx_bandwidth = cpu_to_le32(0x00001f40);
145 cp.max_latency = cpu_to_le16(0xffff);
146 cp.voice_setting = cpu_to_le16(hdev->voice_setting);
147 cp.retrans_effort = 0xff;
148
149 hci_send_cmd(hdev, HCI_OP_SETUP_SYNC_CONN, sizeof(cp), &cp);
150 }
151
152 static void hci_conn_timeout(unsigned long arg)
153 {
154 struct hci_conn *conn = (void *) arg;
155 struct hci_dev *hdev = conn->hdev;
156
157 BT_DBG("conn %p state %d", conn, conn->state);
158
159 if (atomic_read(&conn->refcnt))
160 return;
161
162 hci_dev_lock(hdev);
163
164 switch (conn->state) {
165 case BT_CONNECT:
166 if (conn->type == ACL_LINK)
167 hci_acl_connect_cancel(conn);
168 else
169 hci_acl_disconn(conn, 0x13);
170 break;
171 case BT_CONNECTED:
172 hci_acl_disconn(conn, 0x13);
173 break;
174 default:
175 conn->state = BT_CLOSED;
176 break;
177 }
178
179 hci_dev_unlock(hdev);
180 }
181
182 static void hci_conn_idle(unsigned long arg)
183 {
184 struct hci_conn *conn = (void *) arg;
185
186 BT_DBG("conn %p mode %d", conn, conn->mode);
187
188 hci_conn_enter_sniff_mode(conn);
189 }
190
191 struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst)
192 {
193 struct hci_conn *conn;
194
195 BT_DBG("%s dst %s", hdev->name, batostr(dst));
196
197 conn = kzalloc(sizeof(struct hci_conn), GFP_ATOMIC);
198 if (!conn)
199 return NULL;
200
201 bacpy(&conn->dst, dst);
202 conn->hdev = hdev;
203 conn->type = type;
204 conn->mode = HCI_CM_ACTIVE;
205 conn->state = BT_OPEN;
206
207 conn->power_save = 1;
208
209 skb_queue_head_init(&conn->data_q);
210
211 init_timer(&conn->disc_timer);
212 conn->disc_timer.function = hci_conn_timeout;
213 conn->disc_timer.data = (unsigned long) conn;
214
215 init_timer(&conn->idle_timer);
216 conn->idle_timer.function = hci_conn_idle;
217 conn->idle_timer.data = (unsigned long) conn;
218
219 atomic_set(&conn->refcnt, 0);
220
221 hci_dev_hold(hdev);
222
223 tasklet_disable(&hdev->tx_task);
224
225 hci_conn_hash_add(hdev, conn);
226 if (hdev->notify)
227 hdev->notify(hdev, HCI_NOTIFY_CONN_ADD);
228
229 hci_conn_add_sysfs(conn);
230
231 tasklet_enable(&hdev->tx_task);
232
233 return conn;
234 }
235
236 int hci_conn_del(struct hci_conn *conn)
237 {
238 struct hci_dev *hdev = conn->hdev;
239
240 BT_DBG("%s conn %p handle %d", hdev->name, conn, conn->handle);
241
242 del_timer(&conn->idle_timer);
243
244 del_timer(&conn->disc_timer);
245
246 if (conn->type == ACL_LINK) {
247 struct hci_conn *sco = conn->link;
248 if (sco)
249 sco->link = NULL;
250
251 /* Unacked frames */
252 hdev->acl_cnt += conn->sent;
253 } else {
254 struct hci_conn *acl = conn->link;
255 if (acl) {
256 acl->link = NULL;
257 hci_conn_put(acl);
258 }
259 }
260
261 tasklet_disable(&hdev->tx_task);
262
263 hci_conn_del_sysfs(conn);
264
265 hci_conn_hash_del(hdev, conn);
266 if (hdev->notify)
267 hdev->notify(hdev, HCI_NOTIFY_CONN_DEL);
268
269 tasklet_enable(&hdev->tx_task);
270
271 skb_queue_purge(&conn->data_q);
272
273 hci_dev_put(hdev);
274
275 /* will free via device release */
276 put_device(&conn->dev);
277
278 return 0;
279 }
280
281 struct hci_dev *hci_get_route(bdaddr_t *dst, bdaddr_t *src)
282 {
283 int use_src = bacmp(src, BDADDR_ANY);
284 struct hci_dev *hdev = NULL;
285 struct list_head *p;
286
287 BT_DBG("%s -> %s", batostr(src), batostr(dst));
288
289 read_lock_bh(&hci_dev_list_lock);
290
291 list_for_each(p, &hci_dev_list) {
292 struct hci_dev *d = list_entry(p, struct hci_dev, list);
293
294 if (!test_bit(HCI_UP, &d->flags) || test_bit(HCI_RAW, &d->flags))
295 continue;
296
297 /* Simple routing:
298 * No source address - find interface with bdaddr != dst
299 * Source address - find interface with bdaddr == src
300 */
301
302 if (use_src) {
303 if (!bacmp(&d->bdaddr, src)) {
304 hdev = d; break;
305 }
306 } else {
307 if (bacmp(&d->bdaddr, dst)) {
308 hdev = d; break;
309 }
310 }
311 }
312
313 if (hdev)
314 hdev = hci_dev_hold(hdev);
315
316 read_unlock_bh(&hci_dev_list_lock);
317 return hdev;
318 }
319 EXPORT_SYMBOL(hci_get_route);
320
321 /* Create SCO or ACL connection.
322 * Device _must_ be locked */
323 struct hci_conn *hci_connect(struct hci_dev *hdev, int type, bdaddr_t *dst)
324 {
325 struct hci_conn *acl;
326 struct hci_conn *sco;
327
328 BT_DBG("%s dst %s", hdev->name, batostr(dst));
329
330 if (!(acl = hci_conn_hash_lookup_ba(hdev, ACL_LINK, dst))) {
331 if (!(acl = hci_conn_add(hdev, ACL_LINK, dst)))
332 return NULL;
333 }
334
335 hci_conn_hold(acl);
336
337 if (acl->state == BT_OPEN || acl->state == BT_CLOSED)
338 hci_acl_connect(acl);
339
340 if (type == ACL_LINK)
341 return acl;
342
343 if (!(sco = hci_conn_hash_lookup_ba(hdev, type, dst))) {
344 if (!(sco = hci_conn_add(hdev, type, dst))) {
345 hci_conn_put(acl);
346 return NULL;
347 }
348 }
349
350 acl->link = sco;
351 sco->link = acl;
352
353 hci_conn_hold(sco);
354
355 if (acl->state == BT_CONNECTED &&
356 (sco->state == BT_OPEN || sco->state == BT_CLOSED)) {
357 if (lmp_esco_capable(hdev))
358 hci_setup_sync(sco, acl->handle);
359 else
360 hci_add_sco(sco, acl->handle);
361 }
362
363 return sco;
364 }
365 EXPORT_SYMBOL(hci_connect);
366
367 /* Authenticate remote device */
368 int hci_conn_auth(struct hci_conn *conn)
369 {
370 BT_DBG("conn %p", conn);
371
372 if (conn->link_mode & HCI_LM_AUTH)
373 return 1;
374
375 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->pend)) {
376 struct hci_cp_auth_requested cp;
377 cp.handle = cpu_to_le16(conn->handle);
378 hci_send_cmd(conn->hdev, HCI_OP_AUTH_REQUESTED, sizeof(cp), &cp);
379 }
380 return 0;
381 }
382 EXPORT_SYMBOL(hci_conn_auth);
383
384 /* Enable encryption */
385 int hci_conn_encrypt(struct hci_conn *conn)
386 {
387 BT_DBG("conn %p", conn);
388
389 if (conn->link_mode & HCI_LM_ENCRYPT)
390 return 1;
391
392 if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend))
393 return 0;
394
395 if (hci_conn_auth(conn)) {
396 struct hci_cp_set_conn_encrypt cp;
397 cp.handle = cpu_to_le16(conn->handle);
398 cp.encrypt = 1;
399 hci_send_cmd(conn->hdev, HCI_OP_SET_CONN_ENCRYPT, sizeof(cp), &cp);
400 }
401 return 0;
402 }
403 EXPORT_SYMBOL(hci_conn_encrypt);
404
405 /* Change link key */
406 int hci_conn_change_link_key(struct hci_conn *conn)
407 {
408 BT_DBG("conn %p", conn);
409
410 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->pend)) {
411 struct hci_cp_change_conn_link_key cp;
412 cp.handle = cpu_to_le16(conn->handle);
413 hci_send_cmd(conn->hdev, HCI_OP_CHANGE_CONN_LINK_KEY, sizeof(cp), &cp);
414 }
415 return 0;
416 }
417 EXPORT_SYMBOL(hci_conn_change_link_key);
418
419 /* Switch role */
420 int hci_conn_switch_role(struct hci_conn *conn, uint8_t role)
421 {
422 BT_DBG("conn %p", conn);
423
424 if (!role && conn->link_mode & HCI_LM_MASTER)
425 return 1;
426
427 if (!test_and_set_bit(HCI_CONN_RSWITCH_PEND, &conn->pend)) {
428 struct hci_cp_switch_role cp;
429 bacpy(&cp.bdaddr, &conn->dst);
430 cp.role = role;
431 hci_send_cmd(conn->hdev, HCI_OP_SWITCH_ROLE, sizeof(cp), &cp);
432 }
433 return 0;
434 }
435 EXPORT_SYMBOL(hci_conn_switch_role);
436
437 /* Enter active mode */
438 void hci_conn_enter_active_mode(struct hci_conn *conn)
439 {
440 struct hci_dev *hdev = conn->hdev;
441
442 BT_DBG("conn %p mode %d", conn, conn->mode);
443
444 if (test_bit(HCI_RAW, &hdev->flags))
445 return;
446
447 if (conn->mode != HCI_CM_SNIFF || !conn->power_save)
448 goto timer;
449
450 if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
451 struct hci_cp_exit_sniff_mode cp;
452 cp.handle = cpu_to_le16(conn->handle);
453 hci_send_cmd(hdev, HCI_OP_EXIT_SNIFF_MODE, sizeof(cp), &cp);
454 }
455
456 timer:
457 if (hdev->idle_timeout > 0)
458 mod_timer(&conn->idle_timer,
459 jiffies + msecs_to_jiffies(hdev->idle_timeout));
460 }
461
462 /* Enter sniff mode */
463 void hci_conn_enter_sniff_mode(struct hci_conn *conn)
464 {
465 struct hci_dev *hdev = conn->hdev;
466
467 BT_DBG("conn %p mode %d", conn, conn->mode);
468
469 if (test_bit(HCI_RAW, &hdev->flags))
470 return;
471
472 if (!lmp_sniff_capable(hdev) || !lmp_sniff_capable(conn))
473 return;
474
475 if (conn->mode != HCI_CM_ACTIVE || !(conn->link_policy & HCI_LP_SNIFF))
476 return;
477
478 if (lmp_sniffsubr_capable(hdev) && lmp_sniffsubr_capable(conn)) {
479 struct hci_cp_sniff_subrate cp;
480 cp.handle = cpu_to_le16(conn->handle);
481 cp.max_latency = cpu_to_le16(0);
482 cp.min_remote_timeout = cpu_to_le16(0);
483 cp.min_local_timeout = cpu_to_le16(0);
484 hci_send_cmd(hdev, HCI_OP_SNIFF_SUBRATE, sizeof(cp), &cp);
485 }
486
487 if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
488 struct hci_cp_sniff_mode cp;
489 cp.handle = cpu_to_le16(conn->handle);
490 cp.max_interval = cpu_to_le16(hdev->sniff_max_interval);
491 cp.min_interval = cpu_to_le16(hdev->sniff_min_interval);
492 cp.attempt = cpu_to_le16(4);
493 cp.timeout = cpu_to_le16(1);
494 hci_send_cmd(hdev, HCI_OP_SNIFF_MODE, sizeof(cp), &cp);
495 }
496 }
497
498 /* Drop all connection on the device */
499 void hci_conn_hash_flush(struct hci_dev *hdev)
500 {
501 struct hci_conn_hash *h = &hdev->conn_hash;
502 struct list_head *p;
503
504 BT_DBG("hdev %s", hdev->name);
505
506 p = h->list.next;
507 while (p != &h->list) {
508 struct hci_conn *c;
509
510 c = list_entry(p, struct hci_conn, list);
511 p = p->next;
512
513 c->state = BT_CLOSED;
514
515 hci_proto_disconn_ind(c, 0x16);
516 hci_conn_del(c);
517 }
518 }
519
520 /* Check pending connect attempts */
521 void hci_conn_check_pending(struct hci_dev *hdev)
522 {
523 struct hci_conn *conn;
524
525 BT_DBG("hdev %s", hdev->name);
526
527 hci_dev_lock(hdev);
528
529 conn = hci_conn_hash_lookup_state(hdev, ACL_LINK, BT_CONNECT2);
530 if (conn)
531 hci_acl_connect(conn);
532
533 hci_dev_unlock(hdev);
534 }
535
536 int hci_get_conn_list(void __user *arg)
537 {
538 struct hci_conn_list_req req, *cl;
539 struct hci_conn_info *ci;
540 struct hci_dev *hdev;
541 struct list_head *p;
542 int n = 0, size, err;
543
544 if (copy_from_user(&req, arg, sizeof(req)))
545 return -EFAULT;
546
547 if (!req.conn_num || req.conn_num > (PAGE_SIZE * 2) / sizeof(*ci))
548 return -EINVAL;
549
550 size = sizeof(req) + req.conn_num * sizeof(*ci);
551
552 if (!(cl = kmalloc(size, GFP_KERNEL)))
553 return -ENOMEM;
554
555 if (!(hdev = hci_dev_get(req.dev_id))) {
556 kfree(cl);
557 return -ENODEV;
558 }
559
560 ci = cl->conn_info;
561
562 hci_dev_lock_bh(hdev);
563 list_for_each(p, &hdev->conn_hash.list) {
564 register struct hci_conn *c;
565 c = list_entry(p, struct hci_conn, list);
566
567 bacpy(&(ci + n)->bdaddr, &c->dst);
568 (ci + n)->handle = c->handle;
569 (ci + n)->type = c->type;
570 (ci + n)->out = c->out;
571 (ci + n)->state = c->state;
572 (ci + n)->link_mode = c->link_mode;
573 if (++n >= req.conn_num)
574 break;
575 }
576 hci_dev_unlock_bh(hdev);
577
578 cl->dev_id = hdev->id;
579 cl->conn_num = n;
580 size = sizeof(req) + n * sizeof(*ci);
581
582 hci_dev_put(hdev);
583
584 err = copy_to_user(arg, cl, size);
585 kfree(cl);
586
587 return err ? -EFAULT : 0;
588 }
589
590 int hci_get_conn_info(struct hci_dev *hdev, void __user *arg)
591 {
592 struct hci_conn_info_req req;
593 struct hci_conn_info ci;
594 struct hci_conn *conn;
595 char __user *ptr = arg + sizeof(req);
596
597 if (copy_from_user(&req, arg, sizeof(req)))
598 return -EFAULT;
599
600 hci_dev_lock_bh(hdev);
601 conn = hci_conn_hash_lookup_ba(hdev, req.type, &req.bdaddr);
602 if (conn) {
603 bacpy(&ci.bdaddr, &conn->dst);
604 ci.handle = conn->handle;
605 ci.type = conn->type;
606 ci.out = conn->out;
607 ci.state = conn->state;
608 ci.link_mode = conn->link_mode;
609 }
610 hci_dev_unlock_bh(hdev);
611
612 if (!conn)
613 return -ENOENT;
614
615 return copy_to_user(ptr, &ci, sizeof(ci)) ? -EFAULT : 0;
616 }
Linux branches of Pieter du Preez