?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Remove duplicate line
[dragonfly.git] / sys / netbt / hci_event.c
blob4fc277955ce375edfb3e90e4485310a90ebb4ae8
1 /* $DragonFly: src/sys/netbt/hci_event.c,v 1.2 2008/03/18 13:41:42 hasso Exp $ */
2 /* $OpenBSD: src/sys/netbt/hci_event.c,v 1.7 2008/02/24 21:34:48 uwe Exp $ */
3 /* $NetBSD: hci_event.c,v 1.14 2008/02/10 17:40:54 plunky Exp $ */
4
5 /*-
6 * Copyright (c) 2005 Iain Hibbert.
7 * Copyright (c) 2006 Itronix Inc.
8 * All rights reserved.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 * 3. The name of Itronix Inc. may not be used to endorse
19 * or promote products derived from this software without specific
20 * prior written permission.
21 *
22 * THIS SOFTWARE IS PROVIDED BY ITRONIX INC. ``AS IS'' AND
23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
24 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
25 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL ITRONIX INC. BE LIABLE FOR ANY
26 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
27 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
29 * ON ANY THEORY OF LIABILITY, WHETHER IN
30 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
31 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
32 * POSSIBILITY OF SUCH DAMAGE.
33 */
34
35 #include <sys/param.h>
36 #include <sys/kernel.h>
37 #include <sys/malloc.h>
38 #include <sys/mbuf.h>
39 #include <sys/proc.h>
40 #include <sys/systm.h>
41 #include <sys/endian.h>
42 #include <sys/bus.h>
43
44 #include <netbt/bluetooth.h>
45 #include <netbt/hci.h>
46 #include <netbt/sco.h>
47
48 static void hci_event_inquiry_result(struct hci_unit *, struct mbuf *);
49 static void hci_event_rssi_result(struct hci_unit *, struct mbuf *);
50 static void hci_event_command_status(struct hci_unit *, struct mbuf *);
51 static void hci_event_command_compl(struct hci_unit *, struct mbuf *);
52 static void hci_event_con_compl(struct hci_unit *, struct mbuf *);
53 static void hci_event_discon_compl(struct hci_unit *, struct mbuf *);
54 static void hci_event_con_req(struct hci_unit *, struct mbuf *);
55 static void hci_event_num_compl_pkts(struct hci_unit *, struct mbuf *);
56 static void hci_event_auth_compl(struct hci_unit *, struct mbuf *);
57 static void hci_event_encryption_change(struct hci_unit *, struct mbuf *);
58 static void hci_event_change_con_link_key_compl(struct hci_unit *, struct mbuf *);
59 static void hci_event_read_clock_offset_compl(struct hci_unit *, struct mbuf *);
60 static void hci_cmd_read_bdaddr(struct hci_unit *, struct mbuf *);
61 static void hci_cmd_read_buffer_size(struct hci_unit *, struct mbuf *);
62 static void hci_cmd_read_local_features(struct hci_unit *, struct mbuf *);
63 static void hci_cmd_read_local_ver(struct hci_unit *, struct mbuf *);
64 static void hci_cmd_read_local_commands(struct hci_unit *, struct mbuf *);
65 static void hci_cmd_reset(struct hci_unit *, struct mbuf *);
66
67 #ifdef BLUETOOTH_DEBUG
68 int bluetooth_debug = BLUETOOTH_DEBUG;
69
70 static const char *hci_eventnames[] = {
71 /* 0x00 */ "NULL",
72 /* 0x01 */ "INQUIRY COMPLETE",
73 /* 0x02 */ "INQUIRY RESULT",
74 /* 0x03 */ "CONN COMPLETE",
75 /* 0x04 */ "CONN REQ",
76 /* 0x05 */ "DISCONN COMPLETE",
77 /* 0x06 */ "AUTH COMPLETE",
78 /* 0x07 */ "REMOTE NAME REQ COMPLETE",
79 /* 0x08 */ "ENCRYPTION CHANGE",
80 /* 0x09 */ "CHANGE CONN LINK KEY COMPLETE",
81 /* 0x0a */ "MASTER LINK KEY COMPLETE",
82 /* 0x0b */ "READ REMOTE FEATURES COMPLETE",
83 /* 0x0c */ "READ REMOTE VERSION INFO COMPLETE",
84 /* 0x0d */ "QoS SETUP COMPLETE",
85 /* 0x0e */ "COMMAND COMPLETE",
86 /* 0x0f */ "COMMAND STATUS",
87 /* 0x10 */ "HARDWARE ERROR",
88 /* 0x11 */ "FLUSH OCCUR",
89 /* 0x12 */ "ROLE CHANGE",
90 /* 0x13 */ "NUM COMPLETED PACKETS",
91 /* 0x14 */ "MODE CHANGE",
92 /* 0x15 */ "RETURN LINK KEYS",
93 /* 0x16 */ "PIN CODE REQ",
94 /* 0x17 */ "LINK KEY REQ",
95 /* 0x18 */ "LINK KEY NOTIFICATION",
96 /* 0x19 */ "LOOPBACK COMMAND",
97 /* 0x1a */ "DATA BUFFER OVERFLOW",
98 /* 0x1b */ "MAX SLOT CHANGE",
99 /* 0x1c */ "READ CLOCK OFFSET COMPLETE",
100 /* 0x1d */ "CONN PKT TYPE CHANGED",
101 /* 0x1e */ "QOS VIOLATION",
102 /* 0x1f */ "PAGE SCAN MODE CHANGE",
103 /* 0x20 */ "PAGE SCAN REP MODE CHANGE",
104 /* 0x21 */ "FLOW SPECIFICATION COMPLETE",
105 /* 0x22 */ "RSSI RESULT",
106 /* 0x23 */ "READ REMOTE EXT FEATURES",
107 /* 0x24 */ "UNKNOWN",
108 /* 0x25 */ "UNKNOWN",
109 /* 0x26 */ "UNKNOWN",
110 /* 0x27 */ "UNKNOWN",
111 /* 0x28 */ "UNKNOWN",
112 /* 0x29 */ "UNKNOWN",
113 /* 0x2a */ "UNKNOWN",
114 /* 0x2b */ "UNKNOWN",
115 /* 0x2c */ "SCO CON COMPLETE",
116 /* 0x2d */ "SCO CON CHANGED",
117 /* 0x2e */ "SNIFF SUBRATING",
118 /* 0x2f */ "EXTENDED INQUIRY RESULT",
119 /* 0x30 */ "ENCRYPTION KEY REFRESH",
120 /* 0x31 */ "IO CAPABILITY REQUEST",
121 /* 0x32 */ "IO CAPABILITY RESPONSE",
122 /* 0x33 */ "USER CONFIRM REQUEST",
123 /* 0x34 */ "USER PASSKEY REQUEST",
124 /* 0x35 */ "REMOTE OOB DATA REQUEST",
125 /* 0x36 */ "SIMPLE PAIRING COMPLETE",
126 /* 0x37 */ "UNKNOWN",
127 /* 0x38 */ "LINK SUPERVISION TIMEOUT CHANGED",
128 /* 0x39 */ "ENHANCED FLUSH COMPLETE",
129 /* 0x3a */ "UNKNOWN",
130 /* 0x3b */ "USER PASSKEY NOTIFICATION",
131 /* 0x3c */ "KEYPRESS NOTIFICATION",
132 /* 0x3d */ "REMOTE HOST FEATURES NOTIFICATION",
133 };
134
135 static const char *
136 hci_eventstr(unsigned int event)
137 {
138
139 if (event < (sizeof(hci_eventnames) / sizeof(*hci_eventnames)))
140 return hci_eventnames[event];
141
142 switch (event) {
143 case HCI_EVENT_BT_LOGO: /* 0xfe */
144 return "BT_LOGO";
145
146 case HCI_EVENT_VENDOR: /* 0xff */
147 return "VENDOR";
148 }
149
150 return "UNKNOWN";
151 }
152 #endif /* BLUETOOTH_DEBUG */
153
154 /*
155 * process HCI Events
156 *
157 * We will free the mbuf at the end, no need for any sub
158 * functions to handle that. We kind of assume that the
159 * device sends us valid events.
160 */
161 void
162 hci_event(struct mbuf *m, struct hci_unit *unit)
163 {
164 hci_event_hdr_t hdr;
165
166 KKASSERT(m->m_flags & M_PKTHDR);
167
168 KKASSERT(m->m_pkthdr.len >= sizeof(hdr));
169 m_copydata(m, 0, sizeof(hdr), (caddr_t)&hdr);
170 m_adj(m, sizeof(hdr));
171
172 KKASSERT(hdr.type == HCI_EVENT_PKT);
173
174 DPRINTFN(1, "(%s) event %s\n",
175 device_get_nameunit(unit->hci_dev), hci_eventstr(hdr.event));
176
177 switch(hdr.event) {
178 case HCI_EVENT_COMMAND_STATUS:
179 hci_event_command_status(unit, m);
180 break;
181
182 case HCI_EVENT_COMMAND_COMPL:
183 hci_event_command_compl(unit, m);
184 break;
185
186 case HCI_EVENT_NUM_COMPL_PKTS:
187 hci_event_num_compl_pkts(unit, m);
188 break;
189
190 case HCI_EVENT_INQUIRY_RESULT:
191 hci_event_inquiry_result(unit, m);
192 break;
193
194 case HCI_EVENT_RSSI_RESULT:
195 hci_event_rssi_result(unit, m);
196 break;
197
198 case HCI_EVENT_CON_COMPL:
199 hci_event_con_compl(unit, m);
200 break;
201
202 case HCI_EVENT_DISCON_COMPL:
203 hci_event_discon_compl(unit, m);
204 break;
205
206 case HCI_EVENT_CON_REQ:
207 hci_event_con_req(unit, m);
208 break;
209
210 case HCI_EVENT_AUTH_COMPL:
211 hci_event_auth_compl(unit, m);
212 break;
213
214 case HCI_EVENT_ENCRYPTION_CHANGE:
215 hci_event_encryption_change(unit, m);
216 break;
217
218 case HCI_EVENT_CHANGE_CON_LINK_KEY_COMPL:
219 hci_event_change_con_link_key_compl(unit, m);
220 break;
221
222 case HCI_EVENT_READ_CLOCK_OFFSET_COMPL:
223 hci_event_read_clock_offset_compl(unit, m);
224 break;
225
226 default:
227 break;
228 }
229
230 m_freem(m);
231 }
232
233 /*
234 * Command Status
235 *
236 * Update our record of num_cmd_pkts then post-process any pending commands
237 * and optionally restart cmd output on the unit.
238 */
239 static void
240 hci_event_command_status(struct hci_unit *unit, struct mbuf *m)
241 {
242 hci_command_status_ep ep;
243 struct hci_link *link;
244
245 KKASSERT(m->m_pkthdr.len >= sizeof(ep));
246 m_copydata(m, 0, sizeof(ep), (caddr_t)&ep);
247 m_adj(m, sizeof(ep));
248
249 DPRINTFN(1, "(%s) opcode (%03x|%04x) status = 0x%x num_cmd_pkts = %d\n",
250 device_get_nameunit(unit->hci_dev),
251 HCI_OGF(letoh16(ep.opcode)), HCI_OCF(letoh16(ep.opcode)),
252 ep.status,
253 ep.num_cmd_pkts);
254
255 if (ep.status > 0)
256 kprintf("%s: CommandStatus opcode (%03x|%04x) failed "
257 "(status=0x%02x)\n", device_get_nameunit(unit->hci_dev),
258 HCI_OGF(letoh16(ep.opcode)),
259 HCI_OCF(letoh16(ep.opcode)), ep.status);
260
261 unit->hci_num_cmd_pkts = ep.num_cmd_pkts;
262
263 /*
264 * post processing of pending commands
265 */
266 switch(letoh16(ep.opcode)) {
267 case HCI_CMD_CREATE_CON:
268 switch (ep.status) {
269 case 0x12: /* Invalid HCI command parameters */
270 DPRINTF("(%s) Invalid HCI command parameters\n",
271 device_get_nameunit(unit->hci_dev));
272 while ((link = hci_link_lookup_state(unit,
273 HCI_LINK_ACL, HCI_LINK_WAIT_CONNECT)) != NULL)
274 hci_link_free(link, ECONNABORTED);
275 break;
276 }
277 break;
278 default:
279 break;
280 }
281
282 while (unit->hci_num_cmd_pkts > 0 && !IF_QEMPTY(&unit->hci_cmdwait)) {
283 IF_DEQUEUE(&unit->hci_cmdwait, m);
284 hci_output_cmd(unit, m);
285 }
286 }
287
288 /*
289 * Command Complete
290 *
291 * Update our record of num_cmd_pkts then handle the completed command,
292 * and optionally restart cmd output on the unit.
293 */
294 static void
295 hci_event_command_compl(struct hci_unit *unit, struct mbuf *m)
296 {
297 hci_command_compl_ep ep;
298 hci_status_rp rp;
299
300 KKASSERT(m->m_pkthdr.len >= sizeof(ep));
301 m_copydata(m, 0, sizeof(ep), (caddr_t)&ep);
302 m_adj(m, sizeof(ep));
303
304 DPRINTFN(1, "(%s) opcode (%03x|%04x) num_cmd_pkts = %d\n",
305 device_get_nameunit(unit->hci_dev),
306 HCI_OGF(letoh16(ep.opcode)), HCI_OCF(letoh16(ep.opcode)),
307 ep.num_cmd_pkts);
308
309 /*
310 * I am not sure if this is completely correct, it is not guaranteed
311 * that a command_complete packet will contain the status though most
312 * do seem to.
313 */
314 m_copydata(m, 0, sizeof(rp), (caddr_t)&rp);
315 if (rp.status > 0)
316 kprintf("%s: CommandComplete opcode (%03x|%04x) failed (status=0x%02x)\n",
317 device_get_nameunit(unit->hci_dev), HCI_OGF(letoh16(ep.opcode)),
318 HCI_OCF(letoh16(ep.opcode)), rp.status);
319
320 unit->hci_num_cmd_pkts = ep.num_cmd_pkts;
321
322 /*
323 * post processing of completed commands
324 */
325 switch(letoh16(ep.opcode)) {
326 case HCI_CMD_READ_BDADDR:
327 hci_cmd_read_bdaddr(unit, m);
328 break;
329
330 case HCI_CMD_READ_BUFFER_SIZE:
331 hci_cmd_read_buffer_size(unit, m);
332 break;
333
334 case HCI_CMD_READ_LOCAL_FEATURES:
335 hci_cmd_read_local_features(unit, m);
336 break;
337
338 case HCI_CMD_READ_LOCAL_VER:
339 hci_cmd_read_local_ver(unit, m);
340 break;
341
342 case HCI_CMD_READ_LOCAL_COMMANDS:
343 hci_cmd_read_local_commands(unit, m);
344 break;
345
346 case HCI_CMD_RESET:
347 hci_cmd_reset(unit, m);
348 break;
349
350 default:
351 break;
352 }
353
354 while (unit->hci_num_cmd_pkts > 0 && !IF_QEMPTY(&unit->hci_cmdwait)) {
355 IF_DEQUEUE(&unit->hci_cmdwait, m);
356 hci_output_cmd(unit, m);
357 }
358 }
359
360 /*
361 * Number of Completed Packets
362 *
363 * This is sent periodically by the Controller telling us how many
364 * buffers are now freed up and which handle was using them. From
365 * this we determine which type of buffer it was and add the qty
366 * back into the relevant packet counter, then restart output on
367 * links that have halted.
368 */
369 static void
370 hci_event_num_compl_pkts(struct hci_unit *unit, struct mbuf *m)
371 {
372 hci_num_compl_pkts_ep ep;
373 struct hci_link *link, *next;
374 uint16_t handle, num;
375 int num_acl = 0, num_sco = 0;
376
377 KKASSERT(m->m_pkthdr.len >= sizeof(ep));
378 m_copydata(m, 0, sizeof(ep), (caddr_t)&ep);
379 m_adj(m, sizeof(ep));
380
381 while (ep.num_con_handles--) {
382 m_copydata(m, 0, sizeof(handle), (caddr_t)&handle);
383 m_adj(m, sizeof(handle));
384 handle = letoh16(handle);
385
386 m_copydata(m, 0, sizeof(num), (caddr_t)&num);
387 m_adj(m, sizeof(num));
388 num = letoh16(num);
389
390 link = hci_link_lookup_handle(unit, handle);
391 if (link) {
392 if (link->hl_type == HCI_LINK_ACL) {
393 num_acl += num;
394 hci_acl_complete(link, num);
395 } else {
396 num_sco += num;
397 hci_sco_complete(link, num);
398 }
399 } else {
400 /* XXX need to issue Read_Buffer_Size or Reset? */
401 kprintf("%s: unknown handle %d! "
402 "(losing track of %d packet buffer%s)\n",
403 device_get_nameunit(unit->hci_dev), handle,
404 num, (num == 1 ? "" : "s"));
405 }
406 }
407
408 /*
409 * Move up any queued packets. When a link has sent data, it will move
410 * to the back of the queue - technically then if a link had something
411 * to send and there were still buffers available it could get started
412 * twice but it seemed more important to to handle higher loads fairly
413 * than worry about wasting cycles when we are not busy.
414 */
415
416 unit->hci_num_acl_pkts += num_acl;
417 unit->hci_num_sco_pkts += num_sco;
418
419 link = TAILQ_FIRST(&unit->hci_links);
420 while (link && (unit->hci_num_acl_pkts > 0 || unit->hci_num_sco_pkts > 0)) {
421 next = TAILQ_NEXT(link, hl_next);
422
423 if (link->hl_type == HCI_LINK_ACL) {
424 if (unit->hci_num_acl_pkts > 0 && link->hl_txqlen > 0)
425 hci_acl_start(link);
426 } else {
427 if (unit->hci_num_sco_pkts > 0 && link->hl_txqlen > 0)
428 hci_sco_start(link);
429 }
430
431 link = next;
432 }
433 }
434
435 /*
436 * Inquiry Result
437 *
438 * keep a note of devices seen, so we know which unit to use
439 * on outgoing connections
440 */
441 static void
442 hci_event_inquiry_result(struct hci_unit *unit, struct mbuf *m)
443 {
444 hci_inquiry_result_ep ep;
445 hci_inquiry_response ir;
446 struct hci_memo *memo;
447
448 KKASSERT(m->m_pkthdr.len >= sizeof(ep));
449 m_copydata(m, 0, sizeof(ep), (caddr_t)&ep);
450 m_adj(m, sizeof(ep));
451
452 DPRINTFN(1, "(%s) %d response%s\n", device_get_nameunit(unit->hci_dev),
453 ep.num_responses, (ep.num_responses == 1 ? "" : "s"));
454
455 while(ep.num_responses--) {
456 KKASSERT(m->m_pkthdr.len >= sizeof(ir));
457 m_copydata(m, 0, sizeof(ir), (caddr_t)&ir);
458 m_adj(m, sizeof(ir));
459
460 DPRINTFN(1, "bdaddr %02x:%02x:%02x:%02x:%02x:%02x\n",
461 ir.bdaddr.b[5], ir.bdaddr.b[4], ir.bdaddr.b[3],
462 ir.bdaddr.b[2], ir.bdaddr.b[1], ir.bdaddr.b[0]);
463
464 memo = hci_memo_new(unit, &ir.bdaddr);
465 if (memo != NULL) {
466 memo->page_scan_rep_mode = ir.page_scan_rep_mode;
467 memo->page_scan_mode = ir.page_scan_mode;
468 memo->clock_offset = ir.clock_offset;
469 }
470 }
471 }
472
473 /*
474 * Inquiry Result with RSSI
475 *
476 * as above but different packet when RSSI result is enabled
477 */
478 static void
479 hci_event_rssi_result(struct hci_unit *unit, struct mbuf *m)
480 {
481 hci_rssi_result_ep ep;
482 hci_rssi_response rr;
483 struct hci_memo *memo;
484
485 KKASSERT(m->m_pkthdr.len >= sizeof(ep));
486 m_copydata(m, 0, sizeof(ep), (caddr_t)&ep);
487 m_adj(m, sizeof(ep));
488
489 DPRINTFN(1, "%d response%s\n", ep.num_responses,
490 (ep.num_responses == 1 ? "" : "s"));
491
492 while(ep.num_responses--) {
493 KKASSERT(m->m_pkthdr.len >= sizeof(rr));
494 m_copydata(m, 0, sizeof(rr), (caddr_t)&rr);
495 m_adj(m, sizeof(rr));
496
497 DPRINTFN(1, "bdaddr %02x:%02x:%02x:%02x:%02x:%02x\n",
498 rr.bdaddr.b[5], rr.bdaddr.b[4], rr.bdaddr.b[3],
499 rr.bdaddr.b[2], rr.bdaddr.b[1], rr.bdaddr.b[0]);
500
501 memo = hci_memo_new(unit, &rr.bdaddr);
502 if (memo != NULL) {
503 memo->page_scan_rep_mode = rr.page_scan_rep_mode;
504 memo->page_scan_mode = 0;
505 memo->clock_offset = rr.clock_offset;
506 }
507 }
508 }
509
510 /*
511 * Connection Complete
512 *
513 * Sent to us when a connection is made. If there is no link
514 * structure already allocated for this, we must have changed
515 * our mind, so just disconnect.
516 */
517 static void
518 hci_event_con_compl(struct hci_unit *unit, struct mbuf *m)
519 {
520 hci_con_compl_ep ep;
521 hci_write_link_policy_settings_cp cp;
522 struct hci_link *link;
523 int err;
524
525 KKASSERT(m->m_pkthdr.len >= sizeof(ep));
526 m_copydata(m, 0, sizeof(ep), (caddr_t)&ep);
527 m_adj(m, sizeof(ep));
528
529 DPRINTFN(1, "(%s) %s connection complete for "
530 "%02x:%02x:%02x:%02x:%02x:%02x status %#x\n",
531 device_get_nameunit(unit->hci_dev),
532 (ep.link_type == HCI_LINK_ACL ? "ACL" : "SCO"),
533 ep.bdaddr.b[5], ep.bdaddr.b[4], ep.bdaddr.b[3],
534 ep.bdaddr.b[2], ep.bdaddr.b[1], ep.bdaddr.b[0],
535 ep.status);
536
537 link = hci_link_lookup_bdaddr(unit, &ep.bdaddr, ep.link_type);
538
539 if (ep.status) {
540 if (link != NULL) {
541 switch (ep.status) {
542 case 0x04: /* "Page Timeout" */
543 err = EHOSTDOWN;
544 break;
545
546 case 0x08: /* "Connection Timed Out" */
547 case 0x10: /* "Connection Accept Timeout Exceeded" */
548 err = ETIMEDOUT;
549 break;
550
551 case 0x16: /* "Connection Terminated by Local Host" */
552 err = 0;
553 break;
554
555 default:
556 err = ECONNREFUSED;
557 break;
558 }
559
560 hci_link_free(link, err);
561 }
562
563 return;
564 }
565
566 if (link == NULL) {
567 hci_discon_cp dp;
568
569 dp.con_handle = ep.con_handle;
570 dp.reason = 0x13; /* "Remote User Terminated Connection" */
571
572 hci_send_cmd(unit, HCI_CMD_DISCONNECT, &dp, sizeof(dp));
573 return;
574 }
575
576 /* XXX could check auth_enable here */
577
578 if (ep.encryption_mode)
579 link->hl_flags |= (HCI_LINK_AUTH | HCI_LINK_ENCRYPT);
580
581 link->hl_state = HCI_LINK_OPEN;
582 link->hl_handle = HCI_CON_HANDLE(letoh16(ep.con_handle));
583
584 if (ep.link_type == HCI_LINK_ACL) {
585 cp.con_handle = ep.con_handle;
586 cp.settings = htole16(unit->hci_link_policy);
587 err = hci_send_cmd(unit, HCI_CMD_WRITE_LINK_POLICY_SETTINGS,
588 &cp, sizeof(cp));
589 if (err)
590 kprintf("%s: Warning, could not write link policy\n",
591 device_get_nameunit(unit->hci_dev));
592
593 err = hci_send_cmd(unit, HCI_CMD_READ_CLOCK_OFFSET,
594 &cp.con_handle, sizeof(cp.con_handle));
595 if (err)
596 kprintf("%s: Warning, could not read clock offset\n",
597 device_get_nameunit(unit->hci_dev));
598
599 err = hci_acl_setmode(link);
600 if (err == EINPROGRESS)
601 return;
602
603 hci_acl_linkmode(link);
604 } else {
605 (*link->hl_sco->sp_proto->connected)(link->hl_sco->sp_upper);
606 }
607 }
608
609 /*
610 * Disconnection Complete
611 *
612 * This is sent in response to a disconnection request, but also if
613 * the remote device goes out of range.
614 */
615 static void
616 hci_event_discon_compl(struct hci_unit *unit, struct mbuf *m)
617 {
618 hci_discon_compl_ep ep;
619 struct hci_link *link;
620
621 KKASSERT(m->m_pkthdr.len >= sizeof(ep));
622 m_copydata(m, 0, sizeof(ep), (caddr_t)&ep);
623 m_adj(m, sizeof(ep));
624
625 ep.con_handle = letoh16(ep.con_handle);
626
627 DPRINTFN(1, "(%s) handle #%d, status=0x%x\n",
628 device_get_nameunit(unit->hci_dev), ep.con_handle, ep.status);
629
630 link = hci_link_lookup_handle(unit, HCI_CON_HANDLE(ep.con_handle));
631 if (link)
632 hci_link_free(link, ENOENT); /* XXX NetBSD used ENOLINK here */
633 }
634
635 /*
636 * Connect Request
637 *
638 * We check upstream for appropriate listeners and accept connections
639 * that are wanted.
640 */
641 static void
642 hci_event_con_req(struct hci_unit *unit, struct mbuf *m)
643 {
644 hci_con_req_ep ep;
645 hci_accept_con_cp ap;
646 hci_reject_con_cp rp;
647 struct hci_link *link;
648
649 KKASSERT(m->m_pkthdr.len >= sizeof(ep));
650 m_copydata(m, 0, sizeof(ep), (caddr_t)&ep);
651 m_adj(m, sizeof(ep));
652
653 DPRINTFN(1, "(%s) bdaddr %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x "
654 "class %2.2x%2.2x%2.2x type %s\n",
655 device_get_nameunit(unit->hci_dev),
656 ep.bdaddr.b[5], ep.bdaddr.b[4], ep.bdaddr.b[3],
657 ep.bdaddr.b[2], ep.bdaddr.b[1], ep.bdaddr.b[0],
658 ep.uclass[0], ep.uclass[1], ep.uclass[2],
659 ep.link_type == HCI_LINK_ACL ? "ACL" : "SCO");
660
661 if (ep.link_type == HCI_LINK_ACL)
662 link = hci_acl_newconn(unit, &ep.bdaddr);
663 else
664 link = hci_sco_newconn(unit, &ep.bdaddr);
665
666 if (link == NULL) {
667 memset(&rp, 0, sizeof(rp));
668 bdaddr_copy(&rp.bdaddr, &ep.bdaddr);
669 rp.reason = 0x0f; /* Unacceptable BD_ADDR */
670
671 hci_send_cmd(unit, HCI_CMD_REJECT_CON, &rp, sizeof(rp));
672 } else {
673 memset(&ap, 0, sizeof(ap));
674 bdaddr_copy(&ap.bdaddr, &ep.bdaddr);
675 if (unit->hci_link_policy & HCI_LINK_POLICY_ENABLE_ROLE_SWITCH)
676 ap.role = HCI_ROLE_MASTER;
677 else
678 ap.role = HCI_ROLE_SLAVE;
679
680 hci_send_cmd(unit, HCI_CMD_ACCEPT_CON, &ap, sizeof(ap));
681 }
682 }
683
684 /*
685 * Auth Complete
686 *
687 * Authentication has been completed on an ACL link. We can notify the
688 * upper layer protocols unless further mode changes are pending.
689 */
690 static void
691 hci_event_auth_compl(struct hci_unit *unit, struct mbuf *m)
692 {
693 hci_auth_compl_ep ep;
694 struct hci_link *link;
695 int err;
696
697 KKASSERT(m->m_pkthdr.len >= sizeof(ep));
698 m_copydata(m, 0, sizeof(ep), (caddr_t)&ep);
699 m_adj(m, sizeof(ep));
700
701 ep.con_handle = HCI_CON_HANDLE(letoh16(ep.con_handle));
702
703 DPRINTFN(1, "(%s) handle #%d, status=0x%x\n",
704 device_get_nameunit(unit->hci_dev), ep.con_handle, ep.status);
705
706 link = hci_link_lookup_handle(unit, ep.con_handle);
707 if (link == NULL || link->hl_type != HCI_LINK_ACL)
708 return;
709
710 if (ep.status == 0) {
711 link->hl_flags |= HCI_LINK_AUTH;
712
713 if (link->hl_state == HCI_LINK_WAIT_AUTH)
714 link->hl_state = HCI_LINK_OPEN;
715
716 err = hci_acl_setmode(link);
717 if (err == EINPROGRESS)
718 return;
719 }
720
721 hci_acl_linkmode(link);
722 }
723
724 /*
725 * Encryption Change
726 *
727 * The encryption status has changed. Basically, we note the change
728 * then notify the upper layer protocol unless further mode changes
729 * are pending.
730 * Note that if encryption gets disabled when it has been requested,
731 * we will attempt to enable it again.. (its a feature not a bug :)
732 */
733 static void
734 hci_event_encryption_change(struct hci_unit *unit, struct mbuf *m)
735 {
736 hci_encryption_change_ep ep;
737 struct hci_link *link;
738 int err;
739
740 KKASSERT(m->m_pkthdr.len >= sizeof(ep));
741 m_copydata(m, 0, sizeof(ep), (caddr_t)&ep);
742 m_adj(m, sizeof(ep));
743
744 ep.con_handle = HCI_CON_HANDLE(letoh16(ep.con_handle));
745
746 DPRINTFN(1, "(%s) handle #%d, status=0x%x, encryption_enable=0x%x\n",
747 device_get_nameunit(unit->hci_dev), ep.con_handle, ep.status,
748 ep.encryption_enable);
749
750 link = hci_link_lookup_handle(unit, ep.con_handle);
751 if (link == NULL || link->hl_type != HCI_LINK_ACL)
752 return;
753
754 if (ep.status == 0) {
755 if (ep.encryption_enable == 0)
756 link->hl_flags &= ~HCI_LINK_ENCRYPT;
757 else
758 link->hl_flags |= (HCI_LINK_AUTH | HCI_LINK_ENCRYPT);
759
760 if (link->hl_state == HCI_LINK_WAIT_ENCRYPT)
761 link->hl_state = HCI_LINK_OPEN;
762
763 err = hci_acl_setmode(link);
764 if (err == EINPROGRESS)
765 return;
766 }
767
768 hci_acl_linkmode(link);
769 }
770
771 /*
772 * Change Connection Link Key Complete
773 *
774 * Link keys are handled in userland but if we are waiting to secure
775 * this link, we should notify the upper protocols. A SECURE request
776 * only needs a single key change, so we can cancel the request.
777 */
778 static void
779 hci_event_change_con_link_key_compl(struct hci_unit *unit, struct mbuf *m)
780 {
781 hci_change_con_link_key_compl_ep ep;
782 struct hci_link *link;
783 int err;
784
785 KKASSERT(m->m_pkthdr.len >= sizeof(ep));
786 m_copydata(m, 0, sizeof(ep), (caddr_t)&ep);
787 m_adj(m, sizeof(ep));
788
789 ep.con_handle = HCI_CON_HANDLE(letoh16(ep.con_handle));
790
791 DPRINTFN(1, "(%s) handle #%d, status=0x%x\n",
792 device_get_nameunit(unit->hci_dev), ep.con_handle, ep.status);
793
794 link = hci_link_lookup_handle(unit, ep.con_handle);
795 if (link == NULL || link->hl_type != HCI_LINK_ACL)
796 return;
797
798 link->hl_flags &= ~HCI_LINK_SECURE_REQ;
799
800 if (ep.status == 0) {
801 link->hl_flags |= (HCI_LINK_AUTH | HCI_LINK_SECURE);
802
803 if (link->hl_state == HCI_LINK_WAIT_SECURE)
804 link->hl_state = HCI_LINK_OPEN;
805
806 err = hci_acl_setmode(link);
807 if (err == EINPROGRESS)
808 return;
809 }
810
811 hci_acl_linkmode(link);
812 }
813
814 /*
815 * Read Clock Offset Complete
816 *
817 * We keep a note of the clock offset of remote devices when a
818 * link is made, in order to facilitate reconnections to the device
819 */
820 static void
821 hci_event_read_clock_offset_compl(struct hci_unit *unit, struct mbuf *m)
822 {
823 hci_read_clock_offset_compl_ep ep;
824 struct hci_link *link;
825
826 KKASSERT(m->m_pkthdr.len >= sizeof(ep));
827 m_copydata(m, 0, sizeof(ep), (caddr_t)&ep);
828 m_adj(m, sizeof(ep));
829
830 DPRINTFN(1, "handle #%d, offset=%u, status=0x%x\n",
831 letoh16(ep.con_handle), letoh16(ep.clock_offset), ep.status);
832
833 ep.con_handle = HCI_CON_HANDLE(letoh16(ep.con_handle));
834 link = hci_link_lookup_handle(unit, ep.con_handle);
835
836 if (ep.status != 0 || link == NULL)
837 return;
838
839 link->hl_clock = ep.clock_offset;
840 }
841
842 /*
843 * process results of read_bdaddr command_complete event
844 */
845 static void
846 hci_cmd_read_bdaddr(struct hci_unit *unit, struct mbuf *m)
847 {
848 hci_read_bdaddr_rp rp;
849
850 KKASSERT(m->m_pkthdr.len >= sizeof(rp));
851 m_copydata(m, 0, sizeof(rp), (caddr_t)&rp);
852 m_adj(m, sizeof(rp));
853
854 if (rp.status > 0)
855 return;
856
857 if ((unit->hci_flags & BTF_INIT_BDADDR) == 0)
858 return;
859
860 bdaddr_copy(&unit->hci_bdaddr, &rp.bdaddr);
861
862 unit->hci_flags &= ~BTF_INIT_BDADDR;
863
864 wakeup(unit);
865 }
866
867 /*
868 * process results of read_buffer_size command_complete event
869 */
870 static void
871 hci_cmd_read_buffer_size(struct hci_unit *unit, struct mbuf *m)
872 {
873 hci_read_buffer_size_rp rp;
874
875 KKASSERT(m->m_pkthdr.len >= sizeof(rp));
876 m_copydata(m, 0, sizeof(rp), (caddr_t)&rp);
877 m_adj(m, sizeof(rp));
878
879 if (rp.status > 0)
880 return;
881
882 if ((unit->hci_flags & BTF_INIT_BUFFER_SIZE) == 0)
883 return;
884
885 unit->hci_max_acl_size = letoh16(rp.max_acl_size);
886 unit->hci_num_acl_pkts = letoh16(rp.num_acl_pkts);
887 unit->hci_max_sco_size = rp.max_sco_size;
888 unit->hci_num_sco_pkts = letoh16(rp.num_sco_pkts);
889
890 unit->hci_flags &= ~BTF_INIT_BUFFER_SIZE;
891
892 wakeup(unit);
893 }
894
895 /*
896 * process results of read_local_features command_complete event
897 */
898 static void
899 hci_cmd_read_local_features(struct hci_unit *unit, struct mbuf *m)
900 {
901 hci_read_local_features_rp rp;
902
903 KKASSERT(m->m_pkthdr.len >= sizeof(rp));
904 m_copydata(m, 0, sizeof(rp), (caddr_t)&rp);
905 m_adj(m, sizeof(rp));
906
907 if (rp.status > 0)
908 return;
909
910 if ((unit->hci_flags & BTF_INIT_FEATURES) == 0)
911 return;
912
913 unit->hci_lmp_mask = 0;
914
915 if (rp.features[0] & HCI_LMP_ROLE_SWITCH)
916 unit->hci_lmp_mask |= HCI_LINK_POLICY_ENABLE_ROLE_SWITCH;
917
918 if (rp.features[0] & HCI_LMP_HOLD_MODE)
919 unit->hci_lmp_mask |= HCI_LINK_POLICY_ENABLE_HOLD_MODE;
920
921 if (rp.features[0] & HCI_LMP_SNIFF_MODE)
922 unit->hci_lmp_mask |= HCI_LINK_POLICY_ENABLE_SNIFF_MODE;
923
924 if (rp.features[1] & HCI_LMP_PARK_MODE)
925 unit->hci_lmp_mask |= HCI_LINK_POLICY_ENABLE_PARK_MODE;
926
927 /* ACL packet mask */
928 unit->hci_acl_mask = HCI_PKT_DM1 | HCI_PKT_DH1;
929
930 if (rp.features[0] & HCI_LMP_3SLOT)
931 unit->hci_acl_mask |= HCI_PKT_DM3 | HCI_PKT_DH3;
932
933 if (rp.features[0] & HCI_LMP_5SLOT)
934 unit->hci_acl_mask |= HCI_PKT_DM5 | HCI_PKT_DH5;
935
936 if ((rp.features[3] & HCI_LMP_EDR_ACL_2MBPS) == 0)
937 unit->hci_acl_mask |= HCI_PKT_2MBPS_DH1
938 | HCI_PKT_2MBPS_DH3
939 | HCI_PKT_2MBPS_DH5;
940
941 if ((rp.features[3] & HCI_LMP_EDR_ACL_3MBPS) == 0)
942 unit->hci_acl_mask |= HCI_PKT_3MBPS_DH1
943 | HCI_PKT_3MBPS_DH3
944 | HCI_PKT_3MBPS_DH5;
945
946 if ((rp.features[4] & HCI_LMP_3SLOT_EDR_ACL) == 0)
947 unit->hci_acl_mask |= HCI_PKT_2MBPS_DH3
948 | HCI_PKT_3MBPS_DH3;
949
950 if ((rp.features[5] & HCI_LMP_5SLOT_EDR_ACL) == 0)
951 unit->hci_acl_mask |= HCI_PKT_2MBPS_DH5
952 | HCI_PKT_3MBPS_DH5;
953
954 unit->hci_packet_type = unit->hci_acl_mask;
955
956 /* SCO packet mask */
957 unit->hci_sco_mask = 0;
958 if (rp.features[1] & HCI_LMP_SCO_LINK)
959 unit->hci_sco_mask |= HCI_PKT_HV1;
960
961 if (rp.features[1] & HCI_LMP_HV2_PKT)
962 unit->hci_sco_mask |= HCI_PKT_HV2;
963
964 if (rp.features[1] & HCI_LMP_HV3_PKT)
965 unit->hci_sco_mask |= HCI_PKT_HV3;
966
967 if (rp.features[3] & HCI_LMP_EV3_PKT)
968 unit->hci_sco_mask |= HCI_PKT_EV3;
969
970 if (rp.features[4] & HCI_LMP_EV4_PKT)
971 unit->hci_sco_mask |= HCI_PKT_EV4;
972
973 if (rp.features[4] & HCI_LMP_EV5_PKT)
974 unit->hci_sco_mask |= HCI_PKT_EV5;
975
976 /* XXX what do 2MBPS/3MBPS/3SLOT eSCO mean? */
977
978 unit->hci_flags &= ~BTF_INIT_FEATURES;
979
980 wakeup(unit);
981
982 DPRINTFN(1, "%s: lmp_mask %4.4x, acl_mask %4.4x, sco_mask %4.4x\n",
983 device_get_nameunit(unit->hci_dev), unit->hci_lmp_mask,
984 unit->hci_acl_mask, unit->hci_sco_mask);
985 }
986
987 /*
988 * process results of read_local_ver command_complete event
989 *
990 * reading local supported commands is only supported from 1.2 spec
991 */
992 static void
993 hci_cmd_read_local_ver(struct hci_unit *unit, struct mbuf *m)
994 {
995 hci_read_local_ver_rp rp;
996
997 KKASSERT(m->m_pkthdr.len >= sizeof(rp));
998 m_copydata(m, 0, sizeof(rp), (caddr_t)&rp);
999 m_adj(m, sizeof(rp));
1000
1001 if (rp.status != 0)
1002 return;
1003
1004 if ((unit->hci_flags & BTF_INIT_COMMANDS) == 0)
1005 return;
1006
1007 if (rp.hci_version < HCI_SPEC_V12) {
1008 unit->hci_flags &= ~BTF_INIT_COMMANDS;
1009 wakeup(unit);
1010 return;
1011 }
1012
1013 hci_send_cmd(unit, HCI_CMD_READ_LOCAL_COMMANDS, NULL, 0);
1014 }
1015
1016 /*
1017 * process results of read_local_commands command_complete event
1018 */
1019 static void
1020 hci_cmd_read_local_commands(struct hci_unit *unit, struct mbuf *m)
1021 {
1022 hci_read_local_commands_rp rp;
1023
1024 KKASSERT(m->m_pkthdr.len >= sizeof(rp));
1025 m_copydata(m, 0, sizeof(rp), (caddr_t)&rp);
1026 m_adj(m, sizeof(rp));
1027
1028 if (rp.status != 0)
1029 return;
1030
1031 if ((unit->hci_flags & BTF_INIT_COMMANDS) == 0)
1032 return;
1033
1034 unit->hci_flags &= ~BTF_INIT_COMMANDS;
1035 memcpy(unit->hci_cmds, rp.commands, HCI_COMMANDS_SIZE);
1036
1037 wakeup(unit);
1038 }
1039
1040 /*
1041 * process results of reset command_complete event
1042 *
1043 * This has killed all the connections, so close down anything we have left,
1044 * and reinitialise the unit.
1045 */
1046 static void
1047 hci_cmd_reset(struct hci_unit *unit, struct mbuf *m)
1048 {
1049 hci_reset_rp rp;
1050 struct hci_link *link, *next;
1051 int acl;
1052
1053 KKASSERT(m->m_pkthdr.len >= sizeof(rp));
1054 m_copydata(m, 0, sizeof(rp), (caddr_t)&rp);
1055 m_adj(m, sizeof(rp));
1056
1057 if (rp.status != 0)
1058 return;
1059
1060 /*
1061 * release SCO links first, since they may be holding
1062 * an ACL link reference.
1063 */
1064 for (acl = 0 ; acl < 2 ; acl++) {
1065 next = TAILQ_FIRST(&unit->hci_links);
1066 while ((link = next) != NULL) {
1067 next = TAILQ_NEXT(link, hl_next);
1068 if (acl || link->hl_type != HCI_LINK_ACL)
1069 hci_link_free(link, ECONNABORTED);
1070 }
1071 }
1072
1073 unit->hci_num_acl_pkts = 0;
1074 unit->hci_num_sco_pkts = 0;
1075
1076 if (hci_send_cmd(unit, HCI_CMD_READ_BDADDR, NULL, 0))
1077 return;
1078
1079 if (hci_send_cmd(unit, HCI_CMD_READ_BUFFER_SIZE, NULL, 0))
1080 return;
1081
1082 if (hci_send_cmd(unit, HCI_CMD_READ_LOCAL_FEATURES, NULL, 0))
1083 return;
1084
1085 if (hci_send_cmd(unit, HCI_CMD_READ_LOCAL_VER, NULL, 0))
1086 return;
1087 }
DragonFly BSD