?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
x86: cpa: move clflush_cache_range()
[wrt350n-kernel.git] / net / bluetooth / hci_conn.c
blob5fc7be206f629972ea32543079a7972bd02bd156
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 setup_timer(&conn->disc_timer, hci_conn_timeout, (unsigned long)conn);
212 setup_timer(&conn->idle_timer, hci_conn_idle, (unsigned long)conn);
213
214 atomic_set(&conn->refcnt, 0);
215
216 hci_dev_hold(hdev);
217
218 tasklet_disable(&hdev->tx_task);
219
220 hci_conn_hash_add(hdev, conn);
221 if (hdev->notify)
222 hdev->notify(hdev, HCI_NOTIFY_CONN_ADD);
223
224 hci_conn_add_sysfs(conn);
225
226 tasklet_enable(&hdev->tx_task);
227
228 return conn;
229 }
230
231 int hci_conn_del(struct hci_conn *conn)
232 {
233 struct hci_dev *hdev = conn->hdev;
234
235 BT_DBG("%s conn %p handle %d", hdev->name, conn, conn->handle);
236
237 del_timer(&conn->idle_timer);
238
239 del_timer(&conn->disc_timer);
240
241 if (conn->type == ACL_LINK) {
242 struct hci_conn *sco = conn->link;
243 if (sco)
244 sco->link = NULL;
245
246 /* Unacked frames */
247 hdev->acl_cnt += conn->sent;
248 } else {
249 struct hci_conn *acl = conn->link;
250 if (acl) {
251 acl->link = NULL;
252 hci_conn_put(acl);
253 }
254 }
255
256 tasklet_disable(&hdev->tx_task);
257 hci_conn_hash_del(hdev, conn);
258 if (hdev->notify)
259 hdev->notify(hdev, HCI_NOTIFY_CONN_DEL);
260 tasklet_enable(&hdev->tx_task);
261 skb_queue_purge(&conn->data_q);
262 hci_conn_del_sysfs(conn);
263 hci_dev_put(hdev);
264
265 return 0;
266 }
267
268 struct hci_dev *hci_get_route(bdaddr_t *dst, bdaddr_t *src)
269 {
270 int use_src = bacmp(src, BDADDR_ANY);
271 struct hci_dev *hdev = NULL;
272 struct list_head *p;
273
274 BT_DBG("%s -> %s", batostr(src), batostr(dst));
275
276 read_lock_bh(&hci_dev_list_lock);
277
278 list_for_each(p, &hci_dev_list) {
279 struct hci_dev *d = list_entry(p, struct hci_dev, list);
280
281 if (!test_bit(HCI_UP, &d->flags) || test_bit(HCI_RAW, &d->flags))
282 continue;
283
284 /* Simple routing:
285 * No source address - find interface with bdaddr != dst
286 * Source address - find interface with bdaddr == src
287 */
288
289 if (use_src) {
290 if (!bacmp(&d->bdaddr, src)) {
291 hdev = d; break;
292 }
293 } else {
294 if (bacmp(&d->bdaddr, dst)) {
295 hdev = d; break;
296 }
297 }
298 }
299
300 if (hdev)
301 hdev = hci_dev_hold(hdev);
302
303 read_unlock_bh(&hci_dev_list_lock);
304 return hdev;
305 }
306 EXPORT_SYMBOL(hci_get_route);
307
308 /* Create SCO or ACL connection.
309 * Device _must_ be locked */
310 struct hci_conn *hci_connect(struct hci_dev *hdev, int type, bdaddr_t *dst)
311 {
312 struct hci_conn *acl;
313 struct hci_conn *sco;
314
315 BT_DBG("%s dst %s", hdev->name, batostr(dst));
316
317 if (!(acl = hci_conn_hash_lookup_ba(hdev, ACL_LINK, dst))) {
318 if (!(acl = hci_conn_add(hdev, ACL_LINK, dst)))
319 return NULL;
320 }
321
322 hci_conn_hold(acl);
323
324 if (acl->state == BT_OPEN || acl->state == BT_CLOSED)
325 hci_acl_connect(acl);
326
327 if (type == ACL_LINK)
328 return acl;
329
330 if (!(sco = hci_conn_hash_lookup_ba(hdev, type, dst))) {
331 if (!(sco = hci_conn_add(hdev, type, dst))) {
332 hci_conn_put(acl);
333 return NULL;
334 }
335 }
336
337 acl->link = sco;
338 sco->link = acl;
339
340 hci_conn_hold(sco);
341
342 if (acl->state == BT_CONNECTED &&
343 (sco->state == BT_OPEN || sco->state == BT_CLOSED)) {
344 if (lmp_esco_capable(hdev))
345 hci_setup_sync(sco, acl->handle);
346 else
347 hci_add_sco(sco, acl->handle);
348 }
349
350 return sco;
351 }
352 EXPORT_SYMBOL(hci_connect);
353
354 /* Authenticate remote device */
355 int hci_conn_auth(struct hci_conn *conn)
356 {
357 BT_DBG("conn %p", conn);
358
359 if (conn->link_mode & HCI_LM_AUTH)
360 return 1;
361
362 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->pend)) {
363 struct hci_cp_auth_requested cp;
364 cp.handle = cpu_to_le16(conn->handle);
365 hci_send_cmd(conn->hdev, HCI_OP_AUTH_REQUESTED, sizeof(cp), &cp);
366 }
367 return 0;
368 }
369 EXPORT_SYMBOL(hci_conn_auth);
370
371 /* Enable encryption */
372 int hci_conn_encrypt(struct hci_conn *conn)
373 {
374 BT_DBG("conn %p", conn);
375
376 if (conn->link_mode & HCI_LM_ENCRYPT)
377 return 1;
378
379 if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend))
380 return 0;
381
382 if (hci_conn_auth(conn)) {
383 struct hci_cp_set_conn_encrypt cp;
384 cp.handle = cpu_to_le16(conn->handle);
385 cp.encrypt = 1;
386 hci_send_cmd(conn->hdev, HCI_OP_SET_CONN_ENCRYPT, sizeof(cp), &cp);
387 }
388 return 0;
389 }
390 EXPORT_SYMBOL(hci_conn_encrypt);
391
392 /* Change link key */
393 int hci_conn_change_link_key(struct hci_conn *conn)
394 {
395 BT_DBG("conn %p", conn);
396
397 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->pend)) {
398 struct hci_cp_change_conn_link_key cp;
399 cp.handle = cpu_to_le16(conn->handle);
400 hci_send_cmd(conn->hdev, HCI_OP_CHANGE_CONN_LINK_KEY, sizeof(cp), &cp);
401 }
402 return 0;
403 }
404 EXPORT_SYMBOL(hci_conn_change_link_key);
405
406 /* Switch role */
407 int hci_conn_switch_role(struct hci_conn *conn, uint8_t role)
408 {
409 BT_DBG("conn %p", conn);
410
411 if (!role && conn->link_mode & HCI_LM_MASTER)
412 return 1;
413
414 if (!test_and_set_bit(HCI_CONN_RSWITCH_PEND, &conn->pend)) {
415 struct hci_cp_switch_role cp;
416 bacpy(&cp.bdaddr, &conn->dst);
417 cp.role = role;
418 hci_send_cmd(conn->hdev, HCI_OP_SWITCH_ROLE, sizeof(cp), &cp);
419 }
420 return 0;
421 }
422 EXPORT_SYMBOL(hci_conn_switch_role);
423
424 /* Enter active mode */
425 void hci_conn_enter_active_mode(struct hci_conn *conn)
426 {
427 struct hci_dev *hdev = conn->hdev;
428
429 BT_DBG("conn %p mode %d", conn, conn->mode);
430
431 if (test_bit(HCI_RAW, &hdev->flags))
432 return;
433
434 if (conn->mode != HCI_CM_SNIFF || !conn->power_save)
435 goto timer;
436
437 if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
438 struct hci_cp_exit_sniff_mode cp;
439 cp.handle = cpu_to_le16(conn->handle);
440 hci_send_cmd(hdev, HCI_OP_EXIT_SNIFF_MODE, sizeof(cp), &cp);
441 }
442
443 timer:
444 if (hdev->idle_timeout > 0)
445 mod_timer(&conn->idle_timer,
446 jiffies + msecs_to_jiffies(hdev->idle_timeout));
447 }
448
449 /* Enter sniff mode */
450 void hci_conn_enter_sniff_mode(struct hci_conn *conn)
451 {
452 struct hci_dev *hdev = conn->hdev;
453
454 BT_DBG("conn %p mode %d", conn, conn->mode);
455
456 if (test_bit(HCI_RAW, &hdev->flags))
457 return;
458
459 if (!lmp_sniff_capable(hdev) || !lmp_sniff_capable(conn))
460 return;
461
462 if (conn->mode != HCI_CM_ACTIVE || !(conn->link_policy & HCI_LP_SNIFF))
463 return;
464
465 if (lmp_sniffsubr_capable(hdev) && lmp_sniffsubr_capable(conn)) {
466 struct hci_cp_sniff_subrate cp;
467 cp.handle = cpu_to_le16(conn->handle);
468 cp.max_latency = cpu_to_le16(0);
469 cp.min_remote_timeout = cpu_to_le16(0);
470 cp.min_local_timeout = cpu_to_le16(0);
471 hci_send_cmd(hdev, HCI_OP_SNIFF_SUBRATE, sizeof(cp), &cp);
472 }
473
474 if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
475 struct hci_cp_sniff_mode cp;
476 cp.handle = cpu_to_le16(conn->handle);
477 cp.max_interval = cpu_to_le16(hdev->sniff_max_interval);
478 cp.min_interval = cpu_to_le16(hdev->sniff_min_interval);
479 cp.attempt = cpu_to_le16(4);
480 cp.timeout = cpu_to_le16(1);
481 hci_send_cmd(hdev, HCI_OP_SNIFF_MODE, sizeof(cp), &cp);
482 }
483 }
484
485 /* Drop all connection on the device */
486 void hci_conn_hash_flush(struct hci_dev *hdev)
487 {
488 struct hci_conn_hash *h = &hdev->conn_hash;
489 struct list_head *p;
490
491 BT_DBG("hdev %s", hdev->name);
492
493 p = h->list.next;
494 while (p != &h->list) {
495 struct hci_conn *c;
496
497 c = list_entry(p, struct hci_conn, list);
498 p = p->next;
499
500 c->state = BT_CLOSED;
501
502 hci_proto_disconn_ind(c, 0x16);
503 hci_conn_del(c);
504 }
505 }
506
507 /* Check pending connect attempts */
508 void hci_conn_check_pending(struct hci_dev *hdev)
509 {
510 struct hci_conn *conn;
511
512 BT_DBG("hdev %s", hdev->name);
513
514 hci_dev_lock(hdev);
515
516 conn = hci_conn_hash_lookup_state(hdev, ACL_LINK, BT_CONNECT2);
517 if (conn)
518 hci_acl_connect(conn);
519
520 hci_dev_unlock(hdev);
521 }
522
523 int hci_get_conn_list(void __user *arg)
524 {
525 struct hci_conn_list_req req, *cl;
526 struct hci_conn_info *ci;
527 struct hci_dev *hdev;
528 struct list_head *p;
529 int n = 0, size, err;
530
531 if (copy_from_user(&req, arg, sizeof(req)))
532 return -EFAULT;
533
534 if (!req.conn_num || req.conn_num > (PAGE_SIZE * 2) / sizeof(*ci))
535 return -EINVAL;
536
537 size = sizeof(req) + req.conn_num * sizeof(*ci);
538
539 if (!(cl = kmalloc(size, GFP_KERNEL)))
540 return -ENOMEM;
541
542 if (!(hdev = hci_dev_get(req.dev_id))) {
543 kfree(cl);
544 return -ENODEV;
545 }
546
547 ci = cl->conn_info;
548
549 hci_dev_lock_bh(hdev);
550 list_for_each(p, &hdev->conn_hash.list) {
551 register struct hci_conn *c;
552 c = list_entry(p, struct hci_conn, list);
553
554 bacpy(&(ci + n)->bdaddr, &c->dst);
555 (ci + n)->handle = c->handle;
556 (ci + n)->type = c->type;
557 (ci + n)->out = c->out;
558 (ci + n)->state = c->state;
559 (ci + n)->link_mode = c->link_mode;
560 if (++n >= req.conn_num)
561 break;
562 }
563 hci_dev_unlock_bh(hdev);
564
565 cl->dev_id = hdev->id;
566 cl->conn_num = n;
567 size = sizeof(req) + n * sizeof(*ci);
568
569 hci_dev_put(hdev);
570
571 err = copy_to_user(arg, cl, size);
572 kfree(cl);
573
574 return err ? -EFAULT : 0;
575 }
576
577 int hci_get_conn_info(struct hci_dev *hdev, void __user *arg)
578 {
579 struct hci_conn_info_req req;
580 struct hci_conn_info ci;
581 struct hci_conn *conn;
582 char __user *ptr = arg + sizeof(req);
583
584 if (copy_from_user(&req, arg, sizeof(req)))
585 return -EFAULT;
586
587 hci_dev_lock_bh(hdev);
588 conn = hci_conn_hash_lookup_ba(hdev, req.type, &req.bdaddr);
589 if (conn) {
590 bacpy(&ci.bdaddr, &conn->dst);
591 ci.handle = conn->handle;
592 ci.type = conn->type;
593 ci.out = conn->out;
594 ci.state = conn->state;
595 ci.link_mode = conn->link_mode;
596 }
597 hci_dev_unlock_bh(hdev);
598
599 if (!conn)
600 return -ENOENT;
601
602 return copy_to_user(ptr, &ci, sizeof(ci)) ? -EFAULT : 0;
603 }
WRT350N Kernel Patches