[SCSI] move the mid-layer printk's over to shost/starget/sdev_printk
[linux-3.10.git] / net / bluetooth / hci_conn.c
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/config.h>
28 #include <linux/module.h>
29
30 #include <linux/types.h>
31 #include <linux/errno.h>
32 #include <linux/kernel.h>
33 #include <linux/sched.h>
34 #include <linux/slab.h>
35 #include <linux/poll.h>
36 #include <linux/fcntl.h>
37 #include <linux/init.h>
38 #include <linux/skbuff.h>
39 #include <linux/interrupt.h>
40 #include <linux/notifier.h>
41 #include <net/sock.h>
42
43 #include <asm/system.h>
44 #include <asm/uaccess.h>
45 #include <asm/unaligned.h>
46
47 #include <net/bluetooth/bluetooth.h>
48 #include <net/bluetooth/hci_core.h>
49
50 #ifndef CONFIG_BT_HCI_CORE_DEBUG
51 #undef  BT_DBG
52 #define BT_DBG(D...)
53 #endif
54
55 static void hci_acl_connect(struct hci_conn *conn)
56 {
57         struct hci_dev *hdev = conn->hdev;
58         struct inquiry_entry *ie;
59         struct hci_cp_create_conn cp;
60
61         BT_DBG("%p", conn);
62
63         conn->state = BT_CONNECT;
64         conn->out   = 1;
65         conn->link_mode = HCI_LM_MASTER;
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, OGF_LINK_CTL, OCF_CREATE_CONN, sizeof(cp), &cp);
86 }
87
88 void hci_acl_disconn(struct hci_conn *conn, __u8 reason)
89 {
90         struct hci_cp_disconnect cp;
91
92         BT_DBG("%p", conn);
93
94         conn->state = BT_DISCONN;
95
96         cp.handle = __cpu_to_le16(conn->handle);
97         cp.reason = reason;
98         hci_send_cmd(conn->hdev, OGF_LINK_CTL, OCF_DISCONNECT, sizeof(cp), &cp);
99 }
100
101 void hci_add_sco(struct hci_conn *conn, __u16 handle)
102 {
103         struct hci_dev *hdev = conn->hdev;
104         struct hci_cp_add_sco cp;
105
106         BT_DBG("%p", conn);
107
108         conn->state = BT_CONNECT;
109         conn->out = 1;
110
111         cp.pkt_type = __cpu_to_le16(hdev->pkt_type & SCO_PTYPE_MASK);
112         cp.handle   = __cpu_to_le16(handle);
113
114         hci_send_cmd(hdev, OGF_LINK_CTL, OCF_ADD_SCO, sizeof(cp), &cp);
115 }
116
117 static void hci_conn_timeout(unsigned long arg)
118 {
119         struct hci_conn *conn = (void *)arg;
120         struct hci_dev  *hdev = conn->hdev;
121
122         BT_DBG("conn %p state %d", conn, conn->state);
123
124         if (atomic_read(&conn->refcnt))
125                 return;
126
127         hci_dev_lock(hdev);
128         if (conn->state == BT_CONNECTED)
129                 hci_acl_disconn(conn, 0x13);
130         else
131                 conn->state = BT_CLOSED;
132         hci_dev_unlock(hdev);
133         return;
134 }
135
136 static void hci_conn_init_timer(struct hci_conn *conn)
137 {
138         init_timer(&conn->timer);
139         conn->timer.function = hci_conn_timeout;
140         conn->timer.data = (unsigned long)conn;
141 }
142
143 struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst)
144 {
145         struct hci_conn *conn;
146
147         BT_DBG("%s dst %s", hdev->name, batostr(dst));
148
149         if (!(conn = kmalloc(sizeof(struct hci_conn), GFP_ATOMIC)))
150                 return NULL;
151         memset(conn, 0, sizeof(struct hci_conn));
152
153         bacpy(&conn->dst, dst);
154         conn->type   = type;
155         conn->hdev   = hdev;
156         conn->state  = BT_OPEN;
157
158         skb_queue_head_init(&conn->data_q);
159         hci_conn_init_timer(conn);
160
161         atomic_set(&conn->refcnt, 0);
162
163         hci_dev_hold(hdev);
164
165         tasklet_disable(&hdev->tx_task);
166
167         hci_conn_hash_add(hdev, conn);
168         if (hdev->notify)
169                 hdev->notify(hdev, HCI_NOTIFY_CONN_ADD);
170
171         tasklet_enable(&hdev->tx_task);
172
173         return conn;
174 }
175
176 int hci_conn_del(struct hci_conn *conn)
177 {
178         struct hci_dev *hdev = conn->hdev;
179
180         BT_DBG("%s conn %p handle %d", hdev->name, conn, conn->handle);
181
182         hci_conn_del_timer(conn);
183
184         if (conn->type == SCO_LINK) {
185                 struct hci_conn *acl = conn->link;
186                 if (acl) {
187                         acl->link = NULL;
188                         hci_conn_put(acl);
189                 }
190         } else {
191                 struct hci_conn *sco = conn->link;
192                 if (sco)
193                         sco->link = NULL;
194
195                 /* Unacked frames */
196                 hdev->acl_cnt += conn->sent;
197         }
198
199         tasklet_disable(&hdev->tx_task);
200
201         hci_conn_hash_del(hdev, conn);
202         if (hdev->notify)
203                 hdev->notify(hdev, HCI_NOTIFY_CONN_DEL);
204
205         tasklet_enable(&hdev->tx_task);
206
207         skb_queue_purge(&conn->data_q);
208
209         hci_dev_put(hdev);
210
211         kfree(conn);
212         return 0;
213 }
214
215 struct hci_dev *hci_get_route(bdaddr_t *dst, bdaddr_t *src)
216 {
217         int use_src = bacmp(src, BDADDR_ANY);
218         struct hci_dev *hdev = NULL;
219         struct list_head *p;
220
221         BT_DBG("%s -> %s", batostr(src), batostr(dst));
222
223         read_lock_bh(&hci_dev_list_lock);
224
225         list_for_each(p, &hci_dev_list) {
226                 struct hci_dev *d = list_entry(p, struct hci_dev, list);
227
228                 if (!test_bit(HCI_UP, &d->flags) || test_bit(HCI_RAW, &d->flags))
229                         continue;
230
231                 /* Simple routing: 
232                  *   No source address - find interface with bdaddr != dst
233                  *   Source address    - find interface with bdaddr == src
234                  */
235
236                 if (use_src) {
237                         if (!bacmp(&d->bdaddr, src)) {
238                                 hdev = d; break;
239                         }
240                 } else {
241                         if (bacmp(&d->bdaddr, dst)) {
242                                 hdev = d; break;
243                         }
244                 }
245         }
246
247         if (hdev)
248                 hdev = hci_dev_hold(hdev);
249
250         read_unlock_bh(&hci_dev_list_lock);
251         return hdev;
252 }
253 EXPORT_SYMBOL(hci_get_route);
254
255 /* Create SCO or ACL connection.
256  * Device _must_ be locked */
257 struct hci_conn * hci_connect(struct hci_dev *hdev, int type, bdaddr_t *dst)
258 {
259         struct hci_conn *acl;
260
261         BT_DBG("%s dst %s", hdev->name, batostr(dst));
262
263         if (!(acl = hci_conn_hash_lookup_ba(hdev, ACL_LINK, dst))) {
264                 if (!(acl = hci_conn_add(hdev, ACL_LINK, dst)))
265                         return NULL;
266         }
267
268         hci_conn_hold(acl);
269
270         if (acl->state == BT_OPEN || acl->state == BT_CLOSED)
271                 hci_acl_connect(acl);
272
273         if (type == SCO_LINK) {
274                 struct hci_conn *sco;
275
276                 if (!(sco = hci_conn_hash_lookup_ba(hdev, SCO_LINK, dst))) {
277                         if (!(sco = hci_conn_add(hdev, SCO_LINK, dst))) {
278                                 hci_conn_put(acl);
279                                 return NULL;
280                         }
281                 }
282                 acl->link = sco;
283                 sco->link = acl;
284
285                 hci_conn_hold(sco);
286
287                 if (acl->state == BT_CONNECTED && 
288                                 (sco->state == BT_OPEN || sco->state == BT_CLOSED))
289                         hci_add_sco(sco, acl->handle);
290
291                 return sco;
292         } else {
293                 return acl;
294         }
295 }
296 EXPORT_SYMBOL(hci_connect);
297
298 /* Authenticate remote device */
299 int hci_conn_auth(struct hci_conn *conn)
300 {
301         BT_DBG("conn %p", conn);
302
303         if (conn->link_mode & HCI_LM_AUTH)
304                 return 1;
305
306         if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->pend)) {
307                 struct hci_cp_auth_requested cp;
308                 cp.handle = __cpu_to_le16(conn->handle);
309                 hci_send_cmd(conn->hdev, OGF_LINK_CTL, OCF_AUTH_REQUESTED, sizeof(cp), &cp);
310         }
311         return 0;
312 }
313 EXPORT_SYMBOL(hci_conn_auth);
314
315 /* Enable encryption */
316 int hci_conn_encrypt(struct hci_conn *conn)
317 {
318         BT_DBG("conn %p", conn);
319
320         if (conn->link_mode & HCI_LM_ENCRYPT)
321                 return 1;
322
323         if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend))
324                 return 0;
325
326         if (hci_conn_auth(conn)) {
327                 struct hci_cp_set_conn_encrypt cp;
328                 cp.handle  = __cpu_to_le16(conn->handle);
329                 cp.encrypt = 1; 
330                 hci_send_cmd(conn->hdev, OGF_LINK_CTL, OCF_SET_CONN_ENCRYPT, sizeof(cp), &cp);
331         }
332         return 0;
333 }
334 EXPORT_SYMBOL(hci_conn_encrypt);
335
336 /* Change link key */
337 int hci_conn_change_link_key(struct hci_conn *conn)
338 {
339         BT_DBG("conn %p", conn);
340
341         if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->pend)) {
342                 struct hci_cp_change_conn_link_key cp;
343                 cp.handle = __cpu_to_le16(conn->handle);
344                 hci_send_cmd(conn->hdev, OGF_LINK_CTL, OCF_CHANGE_CONN_LINK_KEY, sizeof(cp), &cp);
345         }
346         return 0;
347 }
348 EXPORT_SYMBOL(hci_conn_change_link_key);
349
350 /* Switch role */
351 int hci_conn_switch_role(struct hci_conn *conn, uint8_t role)
352 {
353         BT_DBG("conn %p", conn);
354
355         if (!role && conn->link_mode & HCI_LM_MASTER)
356                 return 1;
357
358         if (!test_and_set_bit(HCI_CONN_RSWITCH_PEND, &conn->pend)) {
359                 struct hci_cp_switch_role cp;
360                 bacpy(&cp.bdaddr, &conn->dst);
361                 cp.role = role;
362                 hci_send_cmd(conn->hdev, OGF_LINK_POLICY, OCF_SWITCH_ROLE, sizeof(cp), &cp);
363         }
364         return 0;
365 }
366 EXPORT_SYMBOL(hci_conn_switch_role);
367
368 /* Drop all connection on the device */
369 void hci_conn_hash_flush(struct hci_dev *hdev)
370 {
371         struct hci_conn_hash *h = &hdev->conn_hash;
372         struct list_head *p;
373
374         BT_DBG("hdev %s", hdev->name);
375
376         p = h->list.next;
377         while (p != &h->list) {
378                 struct hci_conn *c;
379
380                 c = list_entry(p, struct hci_conn, list);
381                 p = p->next;
382
383                 c->state = BT_CLOSED;
384
385                 hci_proto_disconn_ind(c, 0x16);
386                 hci_conn_del(c);
387         }
388 }
389
390 int hci_get_conn_list(void __user *arg)
391 {
392         struct hci_conn_list_req req, *cl;
393         struct hci_conn_info *ci;
394         struct hci_dev *hdev;
395         struct list_head *p;
396         int n = 0, size, err;
397
398         if (copy_from_user(&req, arg, sizeof(req)))
399                 return -EFAULT;
400
401         if (!req.conn_num || req.conn_num > (PAGE_SIZE * 2) / sizeof(*ci))
402                 return -EINVAL;
403
404         size = sizeof(req) + req.conn_num * sizeof(*ci);
405
406         if (!(cl = (void *) kmalloc(size, GFP_KERNEL)))
407                 return -ENOMEM;
408
409         if (!(hdev = hci_dev_get(req.dev_id))) {
410                 kfree(cl);
411                 return -ENODEV;
412         }
413
414         ci = cl->conn_info;
415
416         hci_dev_lock_bh(hdev);
417         list_for_each(p, &hdev->conn_hash.list) {
418                 register struct hci_conn *c;
419                 c = list_entry(p, struct hci_conn, list);
420
421                 bacpy(&(ci + n)->bdaddr, &c->dst);
422                 (ci + n)->handle = c->handle;
423                 (ci + n)->type  = c->type;
424                 (ci + n)->out   = c->out;
425                 (ci + n)->state = c->state;
426                 (ci + n)->link_mode = c->link_mode;
427                 if (++n >= req.conn_num)
428                         break;
429         }
430         hci_dev_unlock_bh(hdev);
431
432         cl->dev_id = hdev->id;
433         cl->conn_num = n;
434         size = sizeof(req) + n * sizeof(*ci);
435
436         hci_dev_put(hdev);
437
438         err = copy_to_user(arg, cl, size);
439         kfree(cl);
440
441         return err ? -EFAULT : 0;
442 }
443
444 int hci_get_conn_info(struct hci_dev *hdev, void __user *arg)
445 {
446         struct hci_conn_info_req req;
447         struct hci_conn_info ci;
448         struct hci_conn *conn;
449         char __user *ptr = arg + sizeof(req);
450
451         if (copy_from_user(&req, arg, sizeof(req)))
452                 return -EFAULT;
453
454         hci_dev_lock_bh(hdev);
455         conn = hci_conn_hash_lookup_ba(hdev, req.type, &req.bdaddr);
456         if (conn) {
457                 bacpy(&ci.bdaddr, &conn->dst);
458                 ci.handle = conn->handle;
459                 ci.type  = conn->type;
460                 ci.out   = conn->out;
461                 ci.state = conn->state;
462                 ci.link_mode = conn->link_mode;
463         }
464         hci_dev_unlock_bh(hdev);
465
466         if (!conn)
467                 return -ENOENT;
468
469         return copy_to_user(ptr, &ci, sizeof(ci)) ? -EFAULT : 0;
470 }