[Bluetooth]: Track page scan repetition mode changes
[linux-3.10.git] / net / bluetooth / hci_event.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 event 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 /* Handle HCI Event packets */
56
57 /* Command Complete OGF LINK_CTL  */
58 static void hci_cc_link_ctl(struct hci_dev *hdev, __u16 ocf, struct sk_buff *skb)
59 {
60         __u8 status;
61
62         BT_DBG("%s ocf 0x%x", hdev->name, ocf);
63
64         switch (ocf) {
65         case OCF_INQUIRY_CANCEL:
66                 status = *((__u8 *) skb->data);
67
68                 if (status) {
69                         BT_DBG("%s Inquiry cancel error: status 0x%x", hdev->name, status);
70                 } else {
71                         clear_bit(HCI_INQUIRY, &hdev->flags);
72                         hci_req_complete(hdev, status);
73                 }
74                 break;
75
76         default:
77                 BT_DBG("%s Command complete: ogf LINK_CTL ocf %x", hdev->name, ocf);
78                 break;
79         }
80 }
81
82 /* Command Complete OGF LINK_POLICY  */
83 static void hci_cc_link_policy(struct hci_dev *hdev, __u16 ocf, struct sk_buff *skb)
84 {
85         struct hci_conn *conn;
86         struct hci_rp_role_discovery *rd;
87
88         BT_DBG("%s ocf 0x%x", hdev->name, ocf);
89
90         switch (ocf) {
91         case OCF_ROLE_DISCOVERY: 
92                 rd = (void *) skb->data;
93
94                 if (rd->status)
95                         break;
96
97                 hci_dev_lock(hdev);
98
99                 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rd->handle));
100                 if (conn) {
101                         if (rd->role)
102                                 conn->link_mode &= ~HCI_LM_MASTER;
103                         else
104                                 conn->link_mode |= HCI_LM_MASTER;
105                 }
106
107                 hci_dev_unlock(hdev);
108                 break;
109
110         default:
111                 BT_DBG("%s: Command complete: ogf LINK_POLICY ocf %x", 
112                                 hdev->name, ocf);
113                 break;
114         }
115 }
116
117 /* Command Complete OGF HOST_CTL  */
118 static void hci_cc_host_ctl(struct hci_dev *hdev, __u16 ocf, struct sk_buff *skb)
119 {
120         __u8 status, param;
121         __u16 setting;
122         struct hci_rp_read_voice_setting *vs;
123         void *sent;
124
125         BT_DBG("%s ocf 0x%x", hdev->name, ocf);
126
127         switch (ocf) {
128         case OCF_RESET:
129                 status = *((__u8 *) skb->data);
130                 hci_req_complete(hdev, status);
131                 break;
132
133         case OCF_SET_EVENT_FLT:
134                 status = *((__u8 *) skb->data);
135                 if (status) {
136                         BT_DBG("%s SET_EVENT_FLT failed %d", hdev->name, status);
137                 } else {
138                         BT_DBG("%s SET_EVENT_FLT succeseful", hdev->name);
139                 }
140                 break;
141
142         case OCF_WRITE_AUTH_ENABLE:
143                 sent = hci_sent_cmd_data(hdev, OGF_HOST_CTL, OCF_WRITE_AUTH_ENABLE);
144                 if (!sent)
145                         break;
146
147                 status = *((__u8 *) skb->data);
148                 param  = *((__u8 *) sent);
149
150                 if (!status) {
151                         if (param == AUTH_ENABLED)
152                                 set_bit(HCI_AUTH, &hdev->flags);
153                         else
154                                 clear_bit(HCI_AUTH, &hdev->flags);
155                 }
156                 hci_req_complete(hdev, status);
157                 break;
158
159         case OCF_WRITE_ENCRYPT_MODE:
160                 sent = hci_sent_cmd_data(hdev, OGF_HOST_CTL, OCF_WRITE_ENCRYPT_MODE);
161                 if (!sent)
162                         break;
163
164                 status = *((__u8 *) skb->data);
165                 param  = *((__u8 *) sent);
166
167                 if (!status) {
168                         if (param)
169                                 set_bit(HCI_ENCRYPT, &hdev->flags);
170                         else
171                                 clear_bit(HCI_ENCRYPT, &hdev->flags);
172                 }
173                 hci_req_complete(hdev, status);
174                 break;
175
176         case OCF_WRITE_CA_TIMEOUT:
177                 status = *((__u8 *) skb->data);
178                 if (status) {
179                         BT_DBG("%s OCF_WRITE_CA_TIMEOUT failed %d", hdev->name, status);
180                 } else {
181                         BT_DBG("%s OCF_WRITE_CA_TIMEOUT succeseful", hdev->name);
182                 }
183                 break;
184
185         case OCF_WRITE_PG_TIMEOUT:
186                 status = *((__u8 *) skb->data);
187                 if (status) {
188                         BT_DBG("%s OCF_WRITE_PG_TIMEOUT failed %d", hdev->name, status);
189                 } else {
190                         BT_DBG("%s: OCF_WRITE_PG_TIMEOUT succeseful", hdev->name);
191                 }
192                 break;
193
194         case OCF_WRITE_SCAN_ENABLE:
195                 sent = hci_sent_cmd_data(hdev, OGF_HOST_CTL, OCF_WRITE_SCAN_ENABLE);
196                 if (!sent)
197                         break;
198
199                 status = *((__u8 *) skb->data);
200                 param  = *((__u8 *) sent);
201
202                 BT_DBG("param 0x%x", param);
203
204                 if (!status) {
205                         clear_bit(HCI_PSCAN, &hdev->flags);
206                         clear_bit(HCI_ISCAN, &hdev->flags);
207                         if (param & SCAN_INQUIRY) 
208                                 set_bit(HCI_ISCAN, &hdev->flags);
209
210                         if (param & SCAN_PAGE) 
211                                 set_bit(HCI_PSCAN, &hdev->flags);
212                 }
213                 hci_req_complete(hdev, status);
214                 break;
215
216         case OCF_READ_VOICE_SETTING:
217                 vs = (struct hci_rp_read_voice_setting *) skb->data;
218
219                 if (vs->status) {
220                         BT_DBG("%s READ_VOICE_SETTING failed %d", hdev->name, vs->status);
221                         break;
222                 }
223
224                 setting = __le16_to_cpu(vs->voice_setting);
225
226                 if (hdev->voice_setting != setting ) {
227                         hdev->voice_setting = setting;
228
229                         BT_DBG("%s: voice setting 0x%04x", hdev->name, setting);
230
231                         if (hdev->notify) {
232                                 tasklet_disable(&hdev->tx_task);
233                                 hdev->notify(hdev, HCI_NOTIFY_VOICE_SETTING);
234                                 tasklet_enable(&hdev->tx_task);
235                         }
236                 }
237                 break;
238
239         case OCF_WRITE_VOICE_SETTING:
240                 sent = hci_sent_cmd_data(hdev, OGF_HOST_CTL, OCF_WRITE_VOICE_SETTING);
241                 if (!sent)
242                         break;
243
244                 status = *((__u8 *) skb->data);
245                 setting = __le16_to_cpu(get_unaligned((__u16 *) sent));
246
247                 if (!status && hdev->voice_setting != setting) {
248                         hdev->voice_setting = setting;
249
250                         BT_DBG("%s: voice setting 0x%04x", hdev->name, setting);
251
252                         if (hdev->notify) {
253                                 tasklet_disable(&hdev->tx_task);
254                                 hdev->notify(hdev, HCI_NOTIFY_VOICE_SETTING);
255                                 tasklet_enable(&hdev->tx_task);
256                         }
257                 }
258                 hci_req_complete(hdev, status);
259                 break;
260
261         case OCF_HOST_BUFFER_SIZE:
262                 status = *((__u8 *) skb->data);
263                 if (status) {
264                         BT_DBG("%s OCF_BUFFER_SIZE failed %d", hdev->name, status);
265                         hci_req_complete(hdev, status);
266                 }
267                 break;
268
269         default:
270                 BT_DBG("%s Command complete: ogf HOST_CTL ocf %x", hdev->name, ocf);
271                 break;
272         }
273 }
274
275 /* Command Complete OGF INFO_PARAM  */
276 static void hci_cc_info_param(struct hci_dev *hdev, __u16 ocf, struct sk_buff *skb)
277 {
278         struct hci_rp_read_loc_features *lf;
279         struct hci_rp_read_buffer_size *bs;
280         struct hci_rp_read_bd_addr *ba;
281
282         BT_DBG("%s ocf 0x%x", hdev->name, ocf);
283
284         switch (ocf) {
285         case OCF_READ_LOCAL_FEATURES:
286                 lf = (struct hci_rp_read_loc_features *) skb->data;
287
288                 if (lf->status) {
289                         BT_DBG("%s READ_LOCAL_FEATURES failed %d", hdev->name, lf->status);
290                         break;
291                 }
292
293                 memcpy(hdev->features, lf->features, sizeof(hdev->features));
294
295                 /* Adjust default settings according to features 
296                  * supported by device. */
297                 if (hdev->features[0] & LMP_3SLOT)
298                         hdev->pkt_type |= (HCI_DM3 | HCI_DH3);
299
300                 if (hdev->features[0] & LMP_5SLOT)
301                         hdev->pkt_type |= (HCI_DM5 | HCI_DH5);
302
303                 if (hdev->features[1] & LMP_HV2)
304                         hdev->pkt_type |= (HCI_HV2);
305
306                 if (hdev->features[1] & LMP_HV3)
307                         hdev->pkt_type |= (HCI_HV3);
308
309                 BT_DBG("%s: features 0x%x 0x%x 0x%x", hdev->name, lf->features[0], lf->features[1], lf->features[2]);
310
311                 break;
312
313         case OCF_READ_BUFFER_SIZE:
314                 bs = (struct hci_rp_read_buffer_size *) skb->data;
315
316                 if (bs->status) {
317                         BT_DBG("%s READ_BUFFER_SIZE failed %d", hdev->name, bs->status);
318                         hci_req_complete(hdev, bs->status);
319                         break;
320                 }
321
322                 hdev->acl_mtu  = __le16_to_cpu(bs->acl_mtu);
323                 hdev->sco_mtu  = bs->sco_mtu ? bs->sco_mtu : 64;
324                 hdev->acl_pkts = hdev->acl_cnt = __le16_to_cpu(bs->acl_max_pkt);
325                 hdev->sco_pkts = hdev->sco_cnt = __le16_to_cpu(bs->sco_max_pkt);
326
327                 BT_DBG("%s mtu: acl %d, sco %d max_pkt: acl %d, sco %d", hdev->name,
328                         hdev->acl_mtu, hdev->sco_mtu, hdev->acl_pkts, hdev->sco_pkts);
329                 break;
330
331         case OCF_READ_BD_ADDR:
332                 ba = (struct hci_rp_read_bd_addr *) skb->data;
333
334                 if (!ba->status) {
335                         bacpy(&hdev->bdaddr, &ba->bdaddr);
336                 } else {
337                         BT_DBG("%s: READ_BD_ADDR failed %d", hdev->name, ba->status);
338                 }
339
340                 hci_req_complete(hdev, ba->status);
341                 break;
342
343         default:
344                 BT_DBG("%s Command complete: ogf INFO_PARAM ocf %x", hdev->name, ocf);
345                 break;
346         }
347 }
348
349 /* Command Status OGF LINK_CTL  */
350 static inline void hci_cs_create_conn(struct hci_dev *hdev, __u8 status)
351 {
352         struct hci_conn *conn;
353         struct hci_cp_create_conn *cp = hci_sent_cmd_data(hdev, OGF_LINK_CTL, OCF_CREATE_CONN);
354
355         if (!cp)
356                 return;
357
358         hci_dev_lock(hdev);
359
360         conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->bdaddr);
361
362         BT_DBG("%s status 0x%x bdaddr %s conn %p", hdev->name,
363                         status, batostr(&cp->bdaddr), conn);
364
365         if (status) {
366                 if (conn && conn->state == BT_CONNECT) {
367                         conn->state = BT_CLOSED;
368                         hci_proto_connect_cfm(conn, status);
369                         hci_conn_del(conn);
370                 }
371         } else {
372                 if (!conn) {
373                         conn = hci_conn_add(hdev, ACL_LINK, &cp->bdaddr);
374                         if (conn) {
375                                 conn->out = 1;
376                                 conn->link_mode |= HCI_LM_MASTER;
377                         } else
378                                 BT_ERR("No memmory for new connection");
379                 }
380         }
381
382         hci_dev_unlock(hdev);
383 }
384
385 static void hci_cs_link_ctl(struct hci_dev *hdev, __u16 ocf, __u8 status)
386 {
387         BT_DBG("%s ocf 0x%x", hdev->name, ocf);
388
389         switch (ocf) {
390         case OCF_CREATE_CONN:
391                 hci_cs_create_conn(hdev, status);
392                 break;
393
394         case OCF_ADD_SCO:
395                 if (status) {
396                         struct hci_conn *acl, *sco;
397                         struct hci_cp_add_sco *cp = hci_sent_cmd_data(hdev, OGF_LINK_CTL, OCF_ADD_SCO);
398                         __u16 handle;
399
400                         if (!cp)
401                                 break;
402
403                         handle = __le16_to_cpu(cp->handle);
404
405                         BT_DBG("%s Add SCO error: handle %d status 0x%x", hdev->name, handle, status);
406
407                         hci_dev_lock(hdev);
408
409                         acl = hci_conn_hash_lookup_handle(hdev, handle);
410                         if (acl && (sco = acl->link)) {
411                                 sco->state = BT_CLOSED;
412
413                                 hci_proto_connect_cfm(sco, status);
414                                 hci_conn_del(sco);
415                         }
416
417                         hci_dev_unlock(hdev);
418                 }
419                 break;
420
421         case OCF_INQUIRY:
422                 if (status) {
423                         BT_DBG("%s Inquiry error: status 0x%x", hdev->name, status);
424                         hci_req_complete(hdev, status);
425                 } else {
426                         set_bit(HCI_INQUIRY, &hdev->flags);
427                 }
428                 break;
429
430         default:
431                 BT_DBG("%s Command status: ogf LINK_CTL ocf %x status %d", 
432                         hdev->name, ocf, status);
433                 break;
434         }
435 }
436
437 /* Command Status OGF LINK_POLICY */
438 static void hci_cs_link_policy(struct hci_dev *hdev, __u16 ocf, __u8 status)
439 {
440         BT_DBG("%s ocf 0x%x", hdev->name, ocf);
441
442         switch (ocf) {
443         default:
444                 BT_DBG("%s Command status: ogf HOST_POLICY ocf %x", hdev->name, ocf);
445                 break;
446         }
447 }
448
449 /* Command Status OGF HOST_CTL */
450 static void hci_cs_host_ctl(struct hci_dev *hdev, __u16 ocf, __u8 status)
451 {
452         BT_DBG("%s ocf 0x%x", hdev->name, ocf);
453
454         switch (ocf) {
455         default:
456                 BT_DBG("%s Command status: ogf HOST_CTL ocf %x", hdev->name, ocf);
457                 break;
458         }
459 }
460
461 /* Command Status OGF INFO_PARAM  */
462 static void hci_cs_info_param(struct hci_dev *hdev, __u16 ocf, __u8 status)
463 {
464         BT_DBG("%s: hci_cs_info_param: ocf 0x%x", hdev->name, ocf);
465
466         switch (ocf) {
467         default:
468                 BT_DBG("%s Command status: ogf INFO_PARAM ocf %x", hdev->name, ocf);
469                 break;
470         }
471 }
472
473 /* Inquiry Complete */
474 static inline void hci_inquiry_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
475 {
476         __u8 status = *((__u8 *) skb->data);
477
478         BT_DBG("%s status %d", hdev->name, status);
479
480         clear_bit(HCI_INQUIRY, &hdev->flags);
481         hci_req_complete(hdev, status);
482 }
483
484 /* Inquiry Result */
485 static inline void hci_inquiry_result_evt(struct hci_dev *hdev, struct sk_buff *skb)
486 {
487         struct inquiry_data data;
488         struct inquiry_info *info = (struct inquiry_info *) (skb->data + 1);
489         int num_rsp = *((__u8 *) skb->data);
490
491         BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
492
493         if (!num_rsp)
494                 return;
495
496         hci_dev_lock(hdev);
497
498         for (; num_rsp; num_rsp--) {
499                 bacpy(&data.bdaddr, &info->bdaddr);
500                 data.pscan_rep_mode     = info->pscan_rep_mode;
501                 data.pscan_period_mode  = info->pscan_period_mode;
502                 data.pscan_mode         = info->pscan_mode;
503                 memcpy(data.dev_class, info->dev_class, 3);
504                 data.clock_offset       = info->clock_offset;
505                 data.rssi               = 0x00;
506                 info++;
507                 hci_inquiry_cache_update(hdev, &data);
508         }
509
510         hci_dev_unlock(hdev);
511 }
512
513 /* Inquiry Result With RSSI */
514 static inline void hci_inquiry_result_with_rssi_evt(struct hci_dev *hdev, struct sk_buff *skb)
515 {
516         struct inquiry_data data;
517         int num_rsp = *((__u8 *) skb->data);
518
519         BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
520
521         if (!num_rsp)
522                 return;
523
524         hci_dev_lock(hdev);
525
526         if ((skb->len - 1) / num_rsp != sizeof(struct inquiry_info_with_rssi)) {
527                 struct inquiry_info_with_rssi_and_pscan_mode *info =
528                         (struct inquiry_info_with_rssi_and_pscan_mode *) (skb->data + 1);
529
530                 for (; num_rsp; num_rsp--) {
531                         bacpy(&data.bdaddr, &info->bdaddr);
532                         data.pscan_rep_mode     = info->pscan_rep_mode;
533                         data.pscan_period_mode  = info->pscan_period_mode;
534                         data.pscan_mode         = info->pscan_mode;
535                         memcpy(data.dev_class, info->dev_class, 3);
536                         data.clock_offset       = info->clock_offset;
537                         data.rssi               = info->rssi;
538                         info++;
539                         hci_inquiry_cache_update(hdev, &data);
540                 }
541         } else {
542                 struct inquiry_info_with_rssi *info =
543                         (struct inquiry_info_with_rssi *) (skb->data + 1);
544
545                 for (; num_rsp; num_rsp--) {
546                         bacpy(&data.bdaddr, &info->bdaddr);
547                         data.pscan_rep_mode     = info->pscan_rep_mode;
548                         data.pscan_period_mode  = info->pscan_period_mode;
549                         data.pscan_mode         = 0x00;
550                         memcpy(data.dev_class, info->dev_class, 3);
551                         data.clock_offset       = info->clock_offset;
552                         data.rssi               = info->rssi;
553                         info++;
554                         hci_inquiry_cache_update(hdev, &data);
555                 }
556         }
557
558         hci_dev_unlock(hdev);
559 }
560
561 /* Connect Request */
562 static inline void hci_conn_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
563 {
564         struct hci_ev_conn_request *ev = (struct hci_ev_conn_request *) skb->data;
565         int mask = hdev->link_mode;
566
567         BT_DBG("%s Connection request: %s type 0x%x", hdev->name,
568                         batostr(&ev->bdaddr), ev->link_type);
569
570         mask |= hci_proto_connect_ind(hdev, &ev->bdaddr, ev->link_type);
571
572         if (mask & HCI_LM_ACCEPT) {
573                 /* Connection accepted */
574                 struct hci_conn *conn;
575                 struct hci_cp_accept_conn_req cp;
576
577                 hci_dev_lock(hdev);
578                 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
579                 if (!conn) {
580                         if (!(conn = hci_conn_add(hdev, ev->link_type, &ev->bdaddr))) {
581                                 BT_ERR("No memmory for new connection");
582                                 hci_dev_unlock(hdev);
583                                 return;
584                         }
585                 }
586                 memcpy(conn->dev_class, ev->dev_class, 3);
587                 conn->state = BT_CONNECT;
588                 hci_dev_unlock(hdev);
589
590                 bacpy(&cp.bdaddr, &ev->bdaddr);
591
592                 if (lmp_rswitch_capable(hdev) && (mask & HCI_LM_MASTER))
593                         cp.role = 0x00; /* Become master */
594                 else
595                         cp.role = 0x01; /* Remain slave */
596
597                 hci_send_cmd(hdev, OGF_LINK_CTL, OCF_ACCEPT_CONN_REQ, sizeof(cp), &cp);
598         } else {
599                 /* Connection rejected */
600                 struct hci_cp_reject_conn_req cp;
601
602                 bacpy(&cp.bdaddr, &ev->bdaddr);
603                 cp.reason = 0x0f;
604                 hci_send_cmd(hdev, OGF_LINK_CTL, OCF_REJECT_CONN_REQ, sizeof(cp), &cp);
605         }
606 }
607
608 /* Connect Complete */
609 static inline void hci_conn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
610 {
611         struct hci_ev_conn_complete *ev = (struct hci_ev_conn_complete *) skb->data;
612         struct hci_conn *conn = NULL;
613
614         BT_DBG("%s", hdev->name);
615
616         hci_dev_lock(hdev);
617
618         conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
619         if (!conn) {
620                 hci_dev_unlock(hdev);
621                 return;
622         }
623
624         if (!ev->status) {
625                 conn->handle = __le16_to_cpu(ev->handle);
626                 conn->state  = BT_CONNECTED;
627
628                 if (test_bit(HCI_AUTH, &hdev->flags))
629                         conn->link_mode |= HCI_LM_AUTH;
630
631                 if (test_bit(HCI_ENCRYPT, &hdev->flags))
632                         conn->link_mode |= HCI_LM_ENCRYPT;
633
634                 /* Set link policy */
635                 if (conn->type == ACL_LINK && hdev->link_policy) {
636                         struct hci_cp_write_link_policy cp;
637                         cp.handle = ev->handle;
638                         cp.policy = __cpu_to_le16(hdev->link_policy);
639                         hci_send_cmd(hdev, OGF_LINK_POLICY, OCF_WRITE_LINK_POLICY, sizeof(cp), &cp);
640                 }
641
642                 /* Set packet type for incoming connection */
643                 if (!conn->out) {
644                         struct hci_cp_change_conn_ptype cp;
645                         cp.handle = ev->handle;
646                         cp.pkt_type = (conn->type == ACL_LINK) ? 
647                                 __cpu_to_le16(hdev->pkt_type & ACL_PTYPE_MASK):
648                                 __cpu_to_le16(hdev->pkt_type & SCO_PTYPE_MASK);
649
650                         hci_send_cmd(hdev, OGF_LINK_CTL, OCF_CHANGE_CONN_PTYPE, sizeof(cp), &cp);
651                 }
652         } else
653                 conn->state = BT_CLOSED;
654
655         if (conn->type == ACL_LINK) {
656                 struct hci_conn *sco = conn->link;
657                 if (sco) {
658                         if (!ev->status)
659                                 hci_add_sco(sco, conn->handle);
660                         else {
661                                 hci_proto_connect_cfm(sco, ev->status);
662                                 hci_conn_del(sco);
663                         }
664                 }
665         }
666
667         hci_proto_connect_cfm(conn, ev->status);
668         if (ev->status)
669                 hci_conn_del(conn);
670
671         hci_dev_unlock(hdev);
672 }
673
674 /* Disconnect Complete */
675 static inline void hci_disconn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
676 {
677         struct hci_ev_disconn_complete *ev = (struct hci_ev_disconn_complete *) skb->data;
678         struct hci_conn *conn = NULL;
679         __u16 handle = __le16_to_cpu(ev->handle);
680
681         BT_DBG("%s status %d", hdev->name, ev->status);
682
683         if (ev->status)
684                 return;
685
686         hci_dev_lock(hdev);
687
688         conn = hci_conn_hash_lookup_handle(hdev, handle);
689         if (conn) {
690                 conn->state = BT_CLOSED;
691                 hci_proto_disconn_ind(conn, ev->reason);
692                 hci_conn_del(conn);
693         }
694
695         hci_dev_unlock(hdev);
696 }
697
698 /* Number of completed packets */
699 static inline void hci_num_comp_pkts_evt(struct hci_dev *hdev, struct sk_buff *skb)
700 {
701         struct hci_ev_num_comp_pkts *ev = (struct hci_ev_num_comp_pkts *) skb->data;
702         __u16 *ptr;
703         int i;
704
705         skb_pull(skb, sizeof(*ev));
706
707         BT_DBG("%s num_hndl %d", hdev->name, ev->num_hndl);
708
709         if (skb->len < ev->num_hndl * 4) {
710                 BT_DBG("%s bad parameters", hdev->name);
711                 return;
712         }
713
714         tasklet_disable(&hdev->tx_task);
715
716         for (i = 0, ptr = (__u16 *) skb->data; i < ev->num_hndl; i++) {
717                 struct hci_conn *conn;
718                 __u16  handle, count;
719
720                 handle = __le16_to_cpu(get_unaligned(ptr++));
721                 count  = __le16_to_cpu(get_unaligned(ptr++));
722
723                 conn = hci_conn_hash_lookup_handle(hdev, handle);
724                 if (conn) {
725                         conn->sent -= count;
726
727                         if (conn->type == SCO_LINK) {
728                                 if ((hdev->sco_cnt += count) > hdev->sco_pkts)
729                                         hdev->sco_cnt = hdev->sco_pkts;
730                         } else {
731                                 if ((hdev->acl_cnt += count) > hdev->acl_pkts)
732                                         hdev->acl_cnt = hdev->acl_pkts;
733                         }
734                 }
735         }
736         hci_sched_tx(hdev);
737
738         tasklet_enable(&hdev->tx_task);
739 }
740
741 /* Role Change */
742 static inline void hci_role_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
743 {
744         struct hci_ev_role_change *ev = (struct hci_ev_role_change *) skb->data;
745         struct hci_conn *conn = NULL;
746
747         BT_DBG("%s status %d", hdev->name, ev->status);
748
749         hci_dev_lock(hdev);
750
751         conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
752         if (conn) {
753                 if (!ev->status) {
754                         if (ev->role)
755                                 conn->link_mode &= ~HCI_LM_MASTER;
756                         else
757                                 conn->link_mode |= HCI_LM_MASTER;
758                 }
759
760                 clear_bit(HCI_CONN_RSWITCH_PEND, &conn->pend);
761
762                 hci_role_switch_cfm(conn, ev->status, ev->role);
763         }
764
765         hci_dev_unlock(hdev);
766 }
767
768 /* Authentication Complete */
769 static inline void hci_auth_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
770 {
771         struct hci_ev_auth_complete *ev = (struct hci_ev_auth_complete *) skb->data;
772         struct hci_conn *conn = NULL;
773         __u16 handle = __le16_to_cpu(ev->handle);
774
775         BT_DBG("%s status %d", hdev->name, ev->status);
776
777         hci_dev_lock(hdev);
778
779         conn = hci_conn_hash_lookup_handle(hdev, handle);
780         if (conn) {
781                 if (!ev->status)
782                         conn->link_mode |= HCI_LM_AUTH;
783
784                 clear_bit(HCI_CONN_AUTH_PEND, &conn->pend);
785
786                 hci_auth_cfm(conn, ev->status);
787
788                 if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend)) {
789                         if (!ev->status) {
790                                 struct hci_cp_set_conn_encrypt cp;
791                                 cp.handle  = __cpu_to_le16(conn->handle);
792                                 cp.encrypt = 1;
793                                 hci_send_cmd(conn->hdev, OGF_LINK_CTL,
794                                                 OCF_SET_CONN_ENCRYPT,
795                                                 sizeof(cp), &cp);
796                         } else {
797                                 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend);
798                                 hci_encrypt_cfm(conn, ev->status, 0x00);
799                         }
800                 }
801         }
802
803         hci_dev_unlock(hdev);
804 }
805
806 /* Encryption Change */
807 static inline void hci_encrypt_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
808 {
809         struct hci_ev_encrypt_change *ev = (struct hci_ev_encrypt_change *) skb->data;
810         struct hci_conn *conn = NULL;
811         __u16 handle = __le16_to_cpu(ev->handle);
812
813         BT_DBG("%s status %d", hdev->name, ev->status);
814
815         hci_dev_lock(hdev);
816
817         conn = hci_conn_hash_lookup_handle(hdev, handle);
818         if (conn) {
819                 if (!ev->status) {
820                         if (ev->encrypt)
821                                 conn->link_mode |= HCI_LM_ENCRYPT;
822                         else
823                                 conn->link_mode &= ~HCI_LM_ENCRYPT;
824                 }
825
826                 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend);
827
828                 hci_encrypt_cfm(conn, ev->status, ev->encrypt);
829         }
830
831         hci_dev_unlock(hdev);
832 }
833
834 /* Change Connection Link Key Complete */
835 static inline void hci_change_conn_link_key_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
836 {
837         struct hci_ev_change_conn_link_key_complete *ev = (struct hci_ev_change_conn_link_key_complete *) skb->data;
838         struct hci_conn *conn = NULL;
839         __u16 handle = __le16_to_cpu(ev->handle);
840
841         BT_DBG("%s status %d", hdev->name, ev->status);
842
843         hci_dev_lock(hdev);
844
845         conn = hci_conn_hash_lookup_handle(hdev, handle);
846         if (conn) {
847                 if (!ev->status)
848                         conn->link_mode |= HCI_LM_SECURE;
849
850                 clear_bit(HCI_CONN_AUTH_PEND, &conn->pend);
851
852                 hci_key_change_cfm(conn, ev->status);
853         }
854
855         hci_dev_unlock(hdev);
856 }
857
858 /* Pin Code Request*/
859 static inline void hci_pin_code_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
860 {
861 }
862
863 /* Link Key Request */
864 static inline void hci_link_key_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
865 {
866 }
867
868 /* Link Key Notification */
869 static inline void hci_link_key_notify_evt(struct hci_dev *hdev, struct sk_buff *skb)
870 {
871 }
872
873 /* Clock Offset */
874 static inline void hci_clock_offset_evt(struct hci_dev *hdev, struct sk_buff *skb)
875 {
876         struct hci_ev_clock_offset *ev = (struct hci_ev_clock_offset *) skb->data;
877         struct hci_conn *conn = NULL;
878         __u16 handle = __le16_to_cpu(ev->handle);
879
880         BT_DBG("%s status %d", hdev->name, ev->status);
881
882         hci_dev_lock(hdev);
883
884         conn = hci_conn_hash_lookup_handle(hdev, handle);
885         if (conn && !ev->status) {
886                 struct inquiry_entry *ie;
887
888                 if ((ie = hci_inquiry_cache_lookup(hdev, &conn->dst))) {
889                         ie->data.clock_offset = ev->clock_offset;
890                         ie->timestamp = jiffies;
891                 }
892         }
893
894         hci_dev_unlock(hdev);
895 }
896
897 /* Page Scan Repetition Mode */
898 static inline void hci_pscan_rep_mode_evt(struct hci_dev *hdev, struct sk_buff *skb)
899 {
900         struct hci_ev_pscan_rep_mode *ev = (struct hci_ev_pscan_rep_mode *) skb->data;
901         struct inquiry_entry *ie;
902
903         BT_DBG("%s", hdev->name);
904
905         hci_dev_lock(hdev);
906
907         if ((ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr))) {
908                 ie->data.pscan_rep_mode = ev->pscan_rep_mode;
909                 ie->timestamp = jiffies;
910         }
911
912         hci_dev_unlock(hdev);
913 }
914
915 void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb)
916 {
917         struct hci_event_hdr *hdr = (struct hci_event_hdr *) skb->data;
918         struct hci_ev_cmd_complete *ec;
919         struct hci_ev_cmd_status *cs;
920         u16 opcode, ocf, ogf;
921
922         skb_pull(skb, HCI_EVENT_HDR_SIZE);
923
924         BT_DBG("%s evt 0x%x", hdev->name, hdr->evt);
925
926         switch (hdr->evt) {
927         case HCI_EV_NUM_COMP_PKTS:
928                 hci_num_comp_pkts_evt(hdev, skb);
929                 break;
930
931         case HCI_EV_INQUIRY_COMPLETE:
932                 hci_inquiry_complete_evt(hdev, skb);
933                 break;
934
935         case HCI_EV_INQUIRY_RESULT:
936                 hci_inquiry_result_evt(hdev, skb);
937                 break;
938
939         case HCI_EV_INQUIRY_RESULT_WITH_RSSI:
940                 hci_inquiry_result_with_rssi_evt(hdev, skb);
941                 break;
942
943         case HCI_EV_CONN_REQUEST:
944                 hci_conn_request_evt(hdev, skb);
945                 break;
946
947         case HCI_EV_CONN_COMPLETE:
948                 hci_conn_complete_evt(hdev, skb);
949                 break;
950
951         case HCI_EV_DISCONN_COMPLETE:
952                 hci_disconn_complete_evt(hdev, skb);
953                 break;
954
955         case HCI_EV_ROLE_CHANGE:
956                 hci_role_change_evt(hdev, skb);
957                 break;
958
959         case HCI_EV_AUTH_COMPLETE:
960                 hci_auth_complete_evt(hdev, skb);
961                 break;
962
963         case HCI_EV_ENCRYPT_CHANGE:
964                 hci_encrypt_change_evt(hdev, skb);
965                 break;
966
967         case HCI_EV_CHANGE_CONN_LINK_KEY_COMPLETE:
968                 hci_change_conn_link_key_complete_evt(hdev, skb);
969                 break;
970
971         case HCI_EV_PIN_CODE_REQ:
972                 hci_pin_code_request_evt(hdev, skb);
973                 break;
974
975         case HCI_EV_LINK_KEY_REQ:
976                 hci_link_key_request_evt(hdev, skb);
977                 break;
978
979         case HCI_EV_LINK_KEY_NOTIFY:
980                 hci_link_key_notify_evt(hdev, skb);
981                 break;
982
983         case HCI_EV_CLOCK_OFFSET:
984                 hci_clock_offset_evt(hdev, skb);
985                 break;
986
987         case HCI_EV_PSCAN_REP_MODE:
988                 hci_pscan_rep_mode_evt(hdev, skb);
989                 break;
990
991         case HCI_EV_CMD_STATUS:
992                 cs = (struct hci_ev_cmd_status *) skb->data;
993                 skb_pull(skb, sizeof(cs));
994
995                 opcode = __le16_to_cpu(cs->opcode);
996                 ogf = hci_opcode_ogf(opcode);
997                 ocf = hci_opcode_ocf(opcode);
998
999                 switch (ogf) {
1000                 case OGF_INFO_PARAM:
1001                         hci_cs_info_param(hdev, ocf, cs->status);
1002                         break;
1003
1004                 case OGF_HOST_CTL:
1005                         hci_cs_host_ctl(hdev, ocf, cs->status);
1006                         break;
1007
1008                 case OGF_LINK_CTL:
1009                         hci_cs_link_ctl(hdev, ocf, cs->status);
1010                         break;
1011
1012                 case OGF_LINK_POLICY:
1013                         hci_cs_link_policy(hdev, ocf, cs->status);
1014                         break;
1015
1016                 default:
1017                         BT_DBG("%s Command Status OGF %x", hdev->name, ogf);
1018                         break;
1019                 }
1020
1021                 if (cs->ncmd) {
1022                         atomic_set(&hdev->cmd_cnt, 1);
1023                         if (!skb_queue_empty(&hdev->cmd_q))
1024                                 hci_sched_cmd(hdev);
1025                 }
1026                 break;
1027
1028         case HCI_EV_CMD_COMPLETE:
1029                 ec = (struct hci_ev_cmd_complete *) skb->data;
1030                 skb_pull(skb, sizeof(*ec));
1031
1032                 opcode = __le16_to_cpu(ec->opcode);
1033                 ogf = hci_opcode_ogf(opcode);
1034                 ocf = hci_opcode_ocf(opcode);
1035
1036                 switch (ogf) {
1037                 case OGF_INFO_PARAM:
1038                         hci_cc_info_param(hdev, ocf, skb);
1039                         break;
1040
1041                 case OGF_HOST_CTL:
1042                         hci_cc_host_ctl(hdev, ocf, skb);
1043                         break;
1044
1045                 case OGF_LINK_CTL:
1046                         hci_cc_link_ctl(hdev, ocf, skb);
1047                         break;
1048
1049                 case OGF_LINK_POLICY:
1050                         hci_cc_link_policy(hdev, ocf, skb);
1051                         break;
1052
1053                 default:
1054                         BT_DBG("%s Command Completed OGF %x", hdev->name, ogf);
1055                         break;
1056                 }
1057
1058                 if (ec->ncmd) {
1059                         atomic_set(&hdev->cmd_cnt, 1);
1060                         if (!skb_queue_empty(&hdev->cmd_q))
1061                                 hci_sched_cmd(hdev);
1062                 }
1063                 break;
1064         }
1065
1066         kfree_skb(skb);
1067         hdev->stat.evt_rx++;
1068 }
1069
1070 /* Generate internal stack event */
1071 void hci_si_event(struct hci_dev *hdev, int type, int dlen, void *data)
1072 {
1073         struct hci_event_hdr *hdr;
1074         struct hci_ev_stack_internal *ev;
1075         struct sk_buff *skb;
1076
1077         skb = bt_skb_alloc(HCI_EVENT_HDR_SIZE + sizeof(*ev) + dlen, GFP_ATOMIC);
1078         if (!skb)
1079                 return;
1080
1081         hdr = (void *) skb_put(skb, HCI_EVENT_HDR_SIZE);
1082         hdr->evt  = HCI_EV_STACK_INTERNAL;
1083         hdr->plen = sizeof(*ev) + dlen;
1084
1085         ev  = (void *) skb_put(skb, sizeof(*ev) + dlen);
1086         ev->type = type;
1087         memcpy(ev->data, data, dlen);
1088
1089         bt_cb(skb)->incoming = 1;
1090         do_gettimeofday(&skb->stamp);
1091
1092         skb->pkt_type = HCI_EVENT_PKT;
1093         skb->dev = (void *) hdev;
1094         hci_send_to_sock(hdev, skb);
1095         kfree_skb(skb);
1096 }