![[BACK]](/icons/back.gif){kind=icon}
Return to hci_link.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / netbt|
Return to hci_link.c CVS log | Up to [local] / sys / netbt |
1.1 nbrk 1: /* $OpenBSD: hci_link.c,v 1.5 2007/07/22 21:05:00 gwk Exp $ */
2: /* $NetBSD: hci_link.c,v 1.11 2007/04/21 06:15:23 plunky Exp $ */
3:
4: /*-
5: * Copyright (c) 2005 Iain Hibbert.
6: * Copyright (c) 2006 Itronix Inc.
7: * All rights reserved.
8: *
9: * Redistribution and use in source and binary forms, with or without
10: * modification, are permitted provided that the following conditions
11: * are met:
12: * 1. Redistributions of source code must retain the above copyright
13: * notice, this list of conditions and the following disclaimer.
14: * 2. Redistributions in binary form must reproduce the above copyright
15: * notice, this list of conditions and the following disclaimer in the
16: * documentation and/or other materials provided with the distribution.
17: * 3. The name of Itronix Inc. may not be used to endorse
18: * or promote products derived from this software without specific
19: * prior written permission.
20: *
21: * THIS SOFTWARE IS PROVIDED BY ITRONIX INC. ``AS IS'' AND
22: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
23: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
24: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL ITRONIX INC. BE LIABLE FOR ANY
25: * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
26: * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
27: * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
28: * ON ANY THEORY OF LIABILITY, WHETHER IN
29: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
31: * POSSIBILITY OF SUCH DAMAGE.
32: */
33:
34: #include <sys/cdefs.h>
35:
36: #include <sys/param.h>
37: #include <sys/kernel.h>
38: #include <sys/malloc.h>
39: #include <sys/mbuf.h>
40: #include <sys/proc.h>
41: #include <sys/queue.h>
42: #include <sys/systm.h>
43:
44: #include <netbt/bluetooth.h>
45: #include <netbt/hci.h>
46: #include <netbt/l2cap.h>
47: #include <netbt/sco.h>
48:
49: /*******************************************************************************
50: *
51: * HCI ACL Connections
52: */
53:
54: /*
55: * Automatically expire unused ACL connections after this number of
56: * seconds (if zero, do not expire unused connections) [sysctl]
57: */
58: int hci_acl_expiry = 10; /* seconds */
59:
60: /*
61: * hci_acl_open(unit, bdaddr)
62: *
63: * open ACL connection to remote bdaddr. Only one ACL connection is permitted
64: * between any two Bluetooth devices, so we look for an existing one before
65: * trying to start a new one.
66: */
67: struct hci_link *
68: hci_acl_open(struct hci_unit *unit, bdaddr_t *bdaddr)
69: {
70: struct hci_link *link;
71: struct hci_memo *memo;
72: hci_create_con_cp cp;
73: int err;
74:
75: KASSERT(unit != NULL);
76: KASSERT(bdaddr != NULL);
77:
78: link = hci_link_lookup_bdaddr(unit, bdaddr, HCI_LINK_ACL);
79: if (link == NULL) {
80: link = hci_link_alloc(unit);
81: if (link == NULL)
82: return NULL;
83:
84: link->hl_type = HCI_LINK_ACL;
85: bdaddr_copy(&link->hl_bdaddr, bdaddr);
86: }
87:
88: switch(link->hl_state) {
89: case HCI_LINK_CLOSED:
90: /*
91: * open connection to remote device
92: */
93: memset(&cp, 0, sizeof(cp));
94: bdaddr_copy(&cp.bdaddr, bdaddr);
95: cp.pkt_type = htole16(unit->hci_packet_type);
96:
97: memo = hci_memo_find(unit, bdaddr);
98: if (memo != NULL) {
99: cp.page_scan_rep_mode = memo->response.page_scan_rep_mode;
100: cp.page_scan_mode = memo->response.page_scan_mode;
101: cp.clock_offset = htole16(memo->response.clock_offset);
102: }
103:
104: if (unit->hci_link_policy & HCI_LINK_POLICY_ENABLE_ROLE_SWITCH)
105: cp.accept_role_switch = 1;
106:
107: err = hci_send_cmd(unit, HCI_CMD_CREATE_CON, &cp, sizeof(cp));
108: if (err) {
109: hci_link_free(link, err);
110: return NULL;
111: }
112:
113: link->hl_state = HCI_LINK_WAIT_CONNECT;
114: break;
115:
116: case HCI_LINK_WAIT_CONNECT:
117: case HCI_LINK_WAIT_AUTH:
118: case HCI_LINK_WAIT_ENCRYPT:
119: case HCI_LINK_WAIT_SECURE:
120: /*
121: * somebody else already trying to connect, we just
122: * sit on the bench with them..
123: */
124: break;
125:
126: case HCI_LINK_OPEN:
127: /*
128: * If already open, halt any expiry timeouts. We dont need
129: * to care about already invoking timeouts since refcnt >0
130: * will keep the link alive.
131: */
132: timeout_del(&link->hl_expire);
133: break;
134:
135: default:
136: UNKNOWN(link->hl_state);
137: return NULL;
138: }
139:
140: /* open */
141: link->hl_refcnt++;
142:
143: return link;
144: }
145:
146: /*
147: * Close ACL connection. When there are no more references to this link,
148: * we can either close it down or schedule a delayed closedown.
149: */
150: void
151: hci_acl_close(struct hci_link *link, int err)
152: {
153:
154: KASSERT(link != NULL);
155:
156: if (--link->hl_refcnt == 0) {
157: if (link->hl_state == HCI_LINK_CLOSED)
158: hci_link_free(link, err);
159: else if (hci_acl_expiry > 0)
160: timeout_add(&link->hl_expire, hci_acl_expiry * hz);
161: }
162: }
163:
164: /*
165: * Incoming ACL connection.
166: *
167: * For now, we accept all connections but it would be better to check
168: * the L2CAP listen list and only accept when there is a listener
169: * available.
170: *
171: * There should not be a link to the same bdaddr already, we check
172: * anyway though its left unhandled for now.
173: */
174: struct hci_link *
175: hci_acl_newconn(struct hci_unit *unit, bdaddr_t *bdaddr)
176: {
177: struct hci_link *link;
178:
179: link = hci_link_lookup_bdaddr(unit, bdaddr, HCI_LINK_ACL);
180: if (link != NULL)
181: return NULL;
182:
183: link = hci_link_alloc(unit);
184: if (link != NULL) {
185: link->hl_state = HCI_LINK_WAIT_CONNECT;
186: link->hl_type = HCI_LINK_ACL;
187: bdaddr_copy(&link->hl_bdaddr, bdaddr);
188:
189: if (hci_acl_expiry > 0)
190: timeout_add(&link->hl_expire, hci_acl_expiry * hz);
191: }
192:
193: return link;
194: }
195:
196: void
197: hci_acl_timeout(void *arg)
198: {
199: struct hci_link *link = arg;
200: hci_discon_cp cp;
201: int s, err;
202:
203: s = splsoftnet();
204:
205: if (link->hl_refcnt > 0)
206: goto out;
207:
208: DPRINTF("link #%d expired\n", link->hl_handle);
209:
210: switch (link->hl_state) {
211: case HCI_LINK_CLOSED:
212: case HCI_LINK_WAIT_CONNECT:
213: hci_link_free(link, ECONNRESET);
214: break;
215:
216: case HCI_LINK_WAIT_AUTH:
217: case HCI_LINK_WAIT_ENCRYPT:
218: case HCI_LINK_WAIT_SECURE:
219: case HCI_LINK_OPEN:
220: cp.con_handle = htole16(link->hl_handle);
221: cp.reason = 0x13; /* "Remote User Terminated Connection" */
222:
223: err = hci_send_cmd(link->hl_unit, HCI_CMD_DISCONNECT,
224: &cp, sizeof(cp));
225:
226: if (err) {
227: DPRINTF("error %d sending HCI_CMD_DISCONNECT\n",
228: err);
229: }
230:
231: break;
232:
233: default:
234: UNKNOWN(link->hl_state);
235: break;
236: }
237:
238: out:
239: splx(s);
240: }
241:
242: /*
243: * Initiate any Link Mode change requests.
244: */
245: int
246: hci_acl_setmode(struct hci_link *link)
247: {
248: int err;
249:
250: KASSERT(link != NULL);
251: KASSERT(link->hl_unit != NULL);
252:
253: if (link->hl_state != HCI_LINK_OPEN)
254: return EINPROGRESS;
255:
256: if ((link->hl_flags & HCI_LINK_AUTH_REQ)
257: && !(link->hl_flags & HCI_LINK_AUTH)) {
258: hci_auth_req_cp cp;
259:
260: DPRINTF("requesting auth for handle #%d\n",
261: link->hl_handle);
262:
263: link->hl_state = HCI_LINK_WAIT_AUTH;
264: cp.con_handle = htole16(link->hl_handle);
265: err = hci_send_cmd(link->hl_unit, HCI_CMD_AUTH_REQ,
266: &cp, sizeof(cp));
267:
268: return (err == 0 ? EINPROGRESS : err);
269: }
270:
271: if ((link->hl_flags & HCI_LINK_ENCRYPT_REQ)
272: && !(link->hl_flags & HCI_LINK_ENCRYPT)) {
273: hci_set_con_encryption_cp cp;
274:
275: /* XXX we should check features for encryption capability */
276:
277: DPRINTF("requesting encryption for handle #%d\n",
278: link->hl_handle);
279:
280: link->hl_state = HCI_LINK_WAIT_ENCRYPT;
281: cp.con_handle = htole16(link->hl_handle);
282: cp.encryption_enable = 0x01;
283:
284: err = hci_send_cmd(link->hl_unit, HCI_CMD_SET_CON_ENCRYPTION,
285: &cp, sizeof(cp));
286:
287: return (err == 0 ? EINPROGRESS : err);
288: }
289:
290: if ((link->hl_flags & HCI_LINK_SECURE_REQ)) {
291: hci_change_con_link_key_cp cp;
292:
293: /* always change link key for SECURE requests */
294: link->hl_flags &= ~HCI_LINK_SECURE;
295:
296: DPRINTF("changing link key for handle #%d\n",
297: link->hl_handle);
298:
299: link->hl_state = HCI_LINK_WAIT_SECURE;
300: cp.con_handle = htole16(link->hl_handle);
301:
302: err = hci_send_cmd(link->hl_unit, HCI_CMD_CHANGE_CON_LINK_KEY,
303: &cp, sizeof(cp));
304:
305: return (err == 0 ? EINPROGRESS : err);
306: }
307:
308: return 0;
309: }
310:
311: /*
312: * Link Mode changed.
313: *
314: * This is called from event handlers when the mode change
315: * is complete. We notify upstream and restart the link.
316: */
317: void
318: hci_acl_linkmode(struct hci_link *link)
319: {
320: struct l2cap_channel *chan, *next;
321: int err, mode = 0;
322:
323: DPRINTF("handle #%d, auth %s, encrypt %s, secure %s\n",
324: link->hl_handle,
325: (link->hl_flags & HCI_LINK_AUTH ? "on" : "off"),
326: (link->hl_flags & HCI_LINK_ENCRYPT ? "on" : "off"),
327: (link->hl_flags & HCI_LINK_SECURE ? "on" : "off"));
328:
329: if (link->hl_flags & HCI_LINK_AUTH)
330: mode |= L2CAP_LM_AUTH;
331:
332: if (link->hl_flags & HCI_LINK_ENCRYPT)
333: mode |= L2CAP_LM_ENCRYPT;
334:
335: if (link->hl_flags & HCI_LINK_SECURE)
336: mode |= L2CAP_LM_SECURE;
337:
338: /*
339: * The link state will only be OPEN here if the mode change
340: * was successful. So, we can proceed with L2CAP connections,
341: * or notify already establshed channels, to allow any that
342: * are dissatisfied to disconnect before we restart.
343: */
344: next = LIST_FIRST(&l2cap_active_list);
345: while ((chan = next) != NULL) {
346: next = LIST_NEXT(chan, lc_ncid);
347:
348: if (chan->lc_link != link)
349: continue;
350:
351: switch(chan->lc_state) {
352: case L2CAP_WAIT_SEND_CONNECT_REQ: /* we are connecting */
353: if ((mode & chan->lc_mode) != chan->lc_mode) {
354: l2cap_close(chan, ECONNABORTED);
355: break;
356: }
357:
358: chan->lc_state = L2CAP_WAIT_RECV_CONNECT_RSP;
359: err = l2cap_send_connect_req(chan);
360: if (err) {
361: l2cap_close(chan, err);
362: break;
363: }
364: break;
365:
366: case L2CAP_WAIT_SEND_CONNECT_RSP: /* they are connecting */
367: if ((mode & chan->lc_mode) != chan->lc_mode) {
368: l2cap_send_connect_rsp(link, chan->lc_ident,
369: 0, chan->lc_rcid,
370: L2CAP_SECURITY_BLOCK);
371:
372: l2cap_close(chan, ECONNABORTED);
373: break;
374: }
375:
376: l2cap_send_connect_rsp(link, chan->lc_ident,
377: chan->lc_lcid, chan->lc_rcid,
378: L2CAP_SUCCESS);
379:
380: chan->lc_state = L2CAP_WAIT_CONFIG;
381: chan->lc_flags |= (L2CAP_WAIT_CONFIG_RSP | L2CAP_WAIT_CONFIG_REQ);
382: err = l2cap_send_config_req(chan);
383: if (err) {
384: l2cap_close(chan, err);
385: break;
386: }
387: break;
388:
389: case L2CAP_WAIT_RECV_CONNECT_RSP:
390: case L2CAP_WAIT_CONFIG:
391: case L2CAP_OPEN: /* already established */
392: (*chan->lc_proto->linkmode)(chan->lc_upper, mode);
393: break;
394:
395: default:
396: break;
397: }
398: }
399:
400: link->hl_state = HCI_LINK_OPEN;
401: hci_acl_start(link);
402: }
403:
404: /*
405: * Receive ACL Data
406: *
407: * we accumulate packet fragments on the hci_link structure
408: * until a full L2CAP frame is ready, then send it on.
409: */
410: void
411: hci_acl_recv(struct mbuf *m, struct hci_unit *unit)
412: {
413: struct hci_link *link;
414: hci_acldata_hdr_t hdr;
415: uint16_t handle, want;
416: int pb, got;
417:
418: KASSERT(m != NULL);
419: KASSERT(unit != NULL);
420:
421: KASSERT(m->m_pkthdr.len >= sizeof(hdr));
422: m_copydata(m, 0, sizeof(hdr), (caddr_t)&hdr);
423: m_adj(m, sizeof(hdr));
424:
425: #ifdef DIAGNOSTIC
426: if (hdr.type != HCI_ACL_DATA_PKT) {
427: printf("%s: bad ACL packet type\n", unit->hci_devname);
428: goto bad;
429: }
430:
431: if (m->m_pkthdr.len != letoh16(hdr.length)) {
432: printf("%s: bad ACL packet length (%d != %d)\n",
433: unit->hci_devname, m->m_pkthdr.len, letoh16(hdr.length));
434: goto bad;
435: }
436: #endif
437:
438: hdr.length = letoh16(hdr.length);
439: hdr.con_handle = letoh16(hdr.con_handle);
440: handle = HCI_CON_HANDLE(hdr.con_handle);
441: pb = HCI_PB_FLAG(hdr.con_handle);
442:
443: link = hci_link_lookup_handle(unit, handle);
444: if (link == NULL) {
445: hci_discon_cp cp;
446:
447: DPRINTF("%s: dumping packet for unknown handle #%d\n",
448: unit->hci_devname, handle);
449:
450: /*
451: * There is no way to find out what this connection handle is
452: * for, just get rid of it. This may happen, if a USB dongle
453: * is plugged into a self powered hub and does not reset when
454: * the system is shut down.
455: */
456: cp.con_handle = htole16(handle);
457: cp.reason = 0x13; /* "Remote User Terminated Connection" */
458: hci_send_cmd(unit, HCI_CMD_DISCONNECT, &cp, sizeof(cp));
459: goto bad;
460: }
461:
462: switch (pb) {
463: case HCI_PACKET_START:
464: if (link->hl_rxp != NULL)
465: printf("%s: dropped incomplete ACL packet\n",
466: unit->hci_devname);
467:
468: if (m->m_pkthdr.len < sizeof(l2cap_hdr_t)) {
469: printf("%s: short ACL packet\n",
470: unit->hci_devname);
471:
472: goto bad;
473: }
474:
475: link->hl_rxp = m;
476: got = m->m_pkthdr.len;
477: break;
478:
479: case HCI_PACKET_FRAGMENT:
480: if (link->hl_rxp == NULL) {
481: printf("%s: unexpected packet fragment\n",
482: unit->hci_devname);
483:
484: goto bad;
485: }
486:
487: got = m->m_pkthdr.len + link->hl_rxp->m_pkthdr.len;
488: m_cat(link->hl_rxp, m);
489: m = link->hl_rxp;
490: m->m_pkthdr.len = got;
491: break;
492:
493: default:
494: printf("%s: unknown packet type\n",
495: unit->hci_devname);
496:
497: goto bad;
498: }
499:
500: m_copydata(m, 0, sizeof(want), (caddr_t)&want);
501: want = letoh16(want) + sizeof(l2cap_hdr_t) - got;
502:
503: if (want > 0)
504: return;
505:
506: link->hl_rxp = NULL;
507:
508: if (want == 0) {
509: l2cap_recv_frame(m, link);
510: return;
511: }
512:
513: bad:
514: m_freem(m);
515: }
516:
517: /*
518: * Send ACL data on link
519: *
520: * We must fragment packets into chunks of less than unit->hci_max_acl_size and
521: * prepend a relevant ACL header to each fragment. We keep a PDU structure
522: * attached to the link, so that completed fragments can be marked off and
523: * more data requested from above once the PDU is sent.
524: */
525: int
526: hci_acl_send(struct mbuf *m, struct hci_link *link,
527: struct l2cap_channel *chan)
528: {
529: struct l2cap_pdu *pdu;
530: struct mbuf *n = NULL;
531: int plen, mlen, num = 0;
532:
533: KASSERT(link != NULL);
534: KASSERT(m != NULL);
535: KASSERT(m->m_flags & M_PKTHDR);
536: KASSERT(m->m_pkthdr.len > 0);
537:
538: if (link->hl_state == HCI_LINK_CLOSED) {
539: m_freem(m);
540: return ENETDOWN;
541: }
542:
543: pdu = pool_get(&l2cap_pdu_pool, PR_NOWAIT);
544: if (pdu == NULL)
545: goto nomem;
546:
547: bzero(pdu, sizeof *pdu);
548: pdu->lp_chan = chan;
549: pdu->lp_pending = 0;
550:
551: plen = m->m_pkthdr.len;
552: mlen = link->hl_unit->hci_max_acl_size;
553:
554: DPRINTFN(5, "%s: handle #%d, plen = %d, max = %d\n",
555: link->hl_unit->hci_devname, link->hl_handle, plen, mlen);
556:
557: while (plen > 0) {
558: if (plen > mlen) {
559: n = m_split(m, mlen, M_DONTWAIT);
560: if (n == NULL)
561: goto nomem;
562: } else {
563: mlen = plen;
564: }
565:
566: if (num++ == 0)
567: m->m_flags |= M_PROTO1; /* tag first fragment */
568:
569: DPRINTFN(10, "chunk of %d (plen = %d) bytes\n", mlen, plen);
570: IF_ENQUEUE(&pdu->lp_data, m);
571: m = n;
572: plen -= mlen;
573: }
574:
575: TAILQ_INSERT_TAIL(&link->hl_txq, pdu, lp_next);
576: link->hl_txqlen += num;
577:
578: hci_acl_start(link);
579:
580: return 0;
581:
582: nomem:
583: if (m) m_freem(m);
584: if (pdu) {
585: IF_PURGE(&pdu->lp_data);
586: pool_put(&l2cap_pdu_pool, pdu);
587: }
588:
589: return ENOMEM;
590: }
591:
592: /*
593: * Start sending ACL data on link.
594: *
595: * This is called when the queue may need restarting: as new data
596: * is queued, after link mode changes have completed, or when device
597: * buffers have cleared.
598: *
599: * We may use all the available packet slots. The reason that we add
600: * the ACL encapsulation here rather than in hci_acl_send() is that L2CAP
601: * signal packets may be queued before the handle is given to us..
602: */
603: void
604: hci_acl_start(struct hci_link *link)
605: {
606: struct hci_unit *unit;
607: hci_acldata_hdr_t *hdr;
608: struct l2cap_pdu *pdu;
609: struct mbuf *m;
610: uint16_t handle;
611:
612: KASSERT(link != NULL);
613:
614: unit = link->hl_unit;
615: KASSERT(unit != NULL);
616:
617: /* this is mainly to block ourselves (below) */
618: if (link->hl_state != HCI_LINK_OPEN)
619: return;
620:
621: if (link->hl_txqlen == 0 || unit->hci_num_acl_pkts == 0)
622: return;
623:
624: /* find first PDU with data to send */
625: pdu = TAILQ_FIRST(&link->hl_txq);
626: for (;;) {
627: if (pdu == NULL)
628: return;
629:
630: if (!IF_IS_EMPTY(&pdu->lp_data))
631: break;
632:
633: pdu = TAILQ_NEXT(pdu, lp_next);
634: }
635:
636: while (unit->hci_num_acl_pkts > 0) {
637: IF_DEQUEUE(&pdu->lp_data, m);
638: KASSERT(m != NULL);
639:
640: if (m->m_flags & M_PROTO1)
641: handle = HCI_MK_CON_HANDLE(link->hl_handle,
642: HCI_PACKET_START, 0);
643: else
644: handle = HCI_MK_CON_HANDLE(link->hl_handle,
645: HCI_PACKET_FRAGMENT, 0);
646:
647: M_PREPEND(m, sizeof(*hdr), M_DONTWAIT);
648: if (m == NULL)
649: break;
650:
651: hdr = mtod(m, hci_acldata_hdr_t *);
652: hdr->type = HCI_ACL_DATA_PKT;
653: hdr->con_handle = htole16(handle);
654: hdr->length = htole16(m->m_pkthdr.len - sizeof(*hdr));
655:
656: link->hl_txqlen--;
657: pdu->lp_pending++;
658:
659: hci_output_acl(unit, m);
660:
661: if (IF_IS_EMPTY(&pdu->lp_data)) {
662: if (pdu->lp_chan) {
663: /*
664: * This should enable streaming of PDUs - when
665: * we have placed all the fragments on the acl
666: * output queue, we trigger the L2CAP layer to
667: * send us down one more. Use a false state so
668: * we dont run into ourselves coming back from
669: * the future..
670: */
671: link->hl_state = HCI_LINK_BLOCK;
672: l2cap_start(pdu->lp_chan);
673: link->hl_state = HCI_LINK_OPEN;
674: }
675:
676: pdu = TAILQ_NEXT(pdu, lp_next);
677: if (pdu == NULL)
678: break;
679: }
680: }
681:
682: /*
683: * We had our turn now, move to the back of the queue to let
684: * other links have a go at the output buffers..
685: */
686: if (TAILQ_NEXT(link, hl_next)) {
687: TAILQ_REMOVE(&unit->hci_links, link, hl_next);
688: TAILQ_INSERT_TAIL(&unit->hci_links, link, hl_next);
689: }
690: }
691:
692: /*
693: * Confirm ACL packets cleared from Controller buffers. We scan our PDU
694: * list to clear pending fragments and signal upstream for more data
695: * when a PDU is complete.
696: */
697: void
698: hci_acl_complete(struct hci_link *link, int num)
699: {
700: struct l2cap_pdu *pdu;
701: struct l2cap_channel *chan;
702:
703: DPRINTFN(5, "handle #%d (%d)\n", link->hl_handle, num);
704:
705: while (num > 0) {
706: pdu = TAILQ_FIRST(&link->hl_txq);
707: if (pdu == NULL) {
708: printf("%s: %d packets completed on handle #%x "
709: "but none pending!\n",
710: link->hl_unit->hci_devname, num,
711: link->hl_handle);
712: return;
713: }
714:
715: if (num >= pdu->lp_pending) {
716: num -= pdu->lp_pending;
717: pdu->lp_pending = 0;
718:
719: if (IF_IS_EMPTY(&pdu->lp_data)) {
720: TAILQ_REMOVE(&link->hl_txq, pdu, lp_next);
721: chan = pdu->lp_chan;
722: if (chan != NULL) {
723: chan->lc_pending--;
724: (*chan->lc_proto->complete)
725: (chan->lc_upper, 1);
726:
727: if (chan->lc_pending == 0)
728: l2cap_start(chan);
729: }
730:
731: pool_put(&l2cap_pdu_pool, pdu);
732: }
733: } else {
734: pdu->lp_pending -= num;
735: num = 0;
736: }
737: }
738: }
739:
740: /*******************************************************************************
741: *
742: * HCI SCO Connections
743: */
744:
745: /*
746: * Incoming SCO Connection. We check the list for anybody willing
747: * to take it.
748: */
749: struct hci_link *
750: hci_sco_newconn(struct hci_unit *unit, bdaddr_t *bdaddr)
751: {
752: struct sockaddr_bt laddr, raddr;
753: struct sco_pcb *pcb, *new;
754: struct hci_link *sco, *acl;
755:
756: memset(&laddr, 0, sizeof(laddr));
757: laddr.bt_len = sizeof(laddr);
758: laddr.bt_family = AF_BLUETOOTH;
759: bdaddr_copy(&laddr.bt_bdaddr, &unit->hci_bdaddr);
760:
761: memset(&raddr, 0, sizeof(raddr));
762: raddr.bt_len = sizeof(raddr);
763: raddr.bt_family = AF_BLUETOOTH;
764: bdaddr_copy(&raddr.bt_bdaddr, bdaddr);
765:
766: /*
767: * There should already be an ACL link up and running before
768: * the controller sends us SCO connection requests, but you
769: * never know..
770: */
771: acl = hci_link_lookup_bdaddr(unit, bdaddr, HCI_LINK_ACL);
772: if (acl == NULL || acl->hl_state != HCI_LINK_OPEN)
773: return NULL;
774:
775: LIST_FOREACH(pcb, &sco_pcb, sp_next) {
776: if ((pcb->sp_flags & SP_LISTENING) == 0)
777: continue;
778:
779: new = (*pcb->sp_proto->newconn)(pcb->sp_upper, &laddr, &raddr);
780: if (new == NULL)
781: continue;
782:
783: /*
784: * Ok, got new pcb so we can start a new link and fill
785: * in all the details.
786: */
787: bdaddr_copy(&new->sp_laddr, &unit->hci_bdaddr);
788: bdaddr_copy(&new->sp_raddr, bdaddr);
789:
790: sco = hci_link_alloc(unit);
791: if (sco == NULL) {
792: sco_detach(&new);
793: return NULL;
794: }
795:
796: sco->hl_type = HCI_LINK_SCO;
797: bdaddr_copy(&sco->hl_bdaddr, bdaddr);
798:
799: sco->hl_link = hci_acl_open(unit, bdaddr);
800: KASSERT(sco->hl_link == acl);
801:
802: sco->hl_sco = new;
803: new->sp_link = sco;
804:
805: new->sp_mtu = unit->hci_max_sco_size;
806: return sco;
807: }
808:
809: return NULL;
810: }
811:
812: /*
813: * receive SCO packet, we only need to strip the header and send
814: * it to the right handler
815: */
816: void
817: hci_sco_recv(struct mbuf *m, struct hci_unit *unit)
818: {
819: struct hci_link *link;
820: hci_scodata_hdr_t hdr;
821: uint16_t handle;
822:
823: KASSERT(m != NULL);
824: KASSERT(unit != NULL);
825:
826: KASSERT(m->m_pkthdr.len >= sizeof(hdr));
827: m_copydata(m, 0, sizeof(hdr), (caddr_t)&hdr);
828: m_adj(m, sizeof(hdr));
829:
830: #ifdef DIAGNOSTIC
831: if (hdr.type != HCI_SCO_DATA_PKT) {
832: printf("%s: bad SCO packet type\n", unit->hci_devname);
833: goto bad;
834: }
835:
836: if (m->m_pkthdr.len != hdr.length) {
837: printf("%s: bad SCO packet length (%d != %d)\n",
838: unit->hci_devname, m->m_pkthdr.len, hdr.length);
839: goto bad;
840: }
841: #endif
842:
843: hdr.con_handle = letoh16(hdr.con_handle);
844: handle = HCI_CON_HANDLE(hdr.con_handle);
845:
846: link = hci_link_lookup_handle(unit, handle);
847: if (link == NULL || link->hl_type == HCI_LINK_ACL) {
848: DPRINTF("%s: dumping packet for unknown handle #%d\n",
849: unit->hci_devname, handle);
850:
851: goto bad;
852: }
853:
854: (*link->hl_sco->sp_proto->input)(link->hl_sco->sp_upper, m);
855: return;
856:
857: bad:
858: m_freem(m);
859: }
860:
861: void
862: hci_sco_start(struct hci_link *link)
863: {
864: }
865:
866: /*
867: * SCO packets have completed at the controller, so we can
868: * signal up to free the buffer space.
869: */
870: void
871: hci_sco_complete(struct hci_link *link, int num)
872: {
873:
874: DPRINTFN(5, "handle #%d (num=%d)\n", link->hl_handle, num);
875: link->hl_sco->sp_pending--;
876: (*link->hl_sco->sp_proto->complete)(link->hl_sco->sp_upper, num);
877: }
878:
879: /*******************************************************************************
880: *
881: * Generic HCI Connection alloc/free/lookup etc
882: */
883:
884: struct hci_link *
885: hci_link_alloc(struct hci_unit *unit)
886: {
887: struct hci_link *link;
888:
889: KASSERT(unit != NULL);
890:
891: link = malloc(sizeof *link, M_BLUETOOTH, M_NOWAIT);
892: if (link == NULL)
893: return NULL;
894: bzero(link, sizeof *link);
895:
896: link->hl_unit = unit;
897: link->hl_state = HCI_LINK_CLOSED;
898:
899: /* init ACL portion */
900: timeout_set(&link->hl_expire, hci_acl_timeout, link);
901:
902: TAILQ_INIT(&link->hl_txq); /* outgoing packets */
903: TAILQ_INIT(&link->hl_reqs); /* request queue */
904:
905: link->hl_mtu = L2CAP_MTU_DEFAULT; /* L2CAP signal mtu */
906: link->hl_flush = L2CAP_FLUSH_TIMO_DEFAULT; /* flush timeout */
907:
908: /* attach to unit */
909: TAILQ_INSERT_HEAD(&unit->hci_links, link, hl_next);
910: return link;
911: }
912:
913: void
914: hci_link_free(struct hci_link *link, int err)
915: {
916: struct l2cap_req *req;
917: struct l2cap_pdu *pdu;
918: struct l2cap_channel *chan, *next;
919:
920: KASSERT(link != NULL);
921:
922: DPRINTF("#%d, type = %d, state = %d, refcnt = %d\n",
923: link->hl_handle, link->hl_type,
924: link->hl_state, link->hl_refcnt);
925:
926: /* ACL reference count */
927: if (link->hl_refcnt > 0) {
928: next = LIST_FIRST(&l2cap_active_list);
929: while ((chan = next) != NULL) {
930: next = LIST_NEXT(chan, lc_ncid);
931: if (chan->lc_link == link)
932: l2cap_close(chan, err);
933: }
934: }
935: KASSERT(link->hl_refcnt == 0);
936:
937: /* ACL L2CAP requests.. */
938: while ((req = TAILQ_FIRST(&link->hl_reqs)) != NULL)
939: l2cap_request_free(req);
940:
941: KASSERT(TAILQ_EMPTY(&link->hl_reqs));
942:
943: /* ACL outgoing data queue */
944: while ((pdu = TAILQ_FIRST(&link->hl_txq)) != NULL) {
945: TAILQ_REMOVE(&link->hl_txq, pdu, lp_next);
946: IF_PURGE(&pdu->lp_data);
947: if (pdu->lp_pending)
948: link->hl_unit->hci_num_acl_pkts += pdu->lp_pending;
949:
950: pool_put(&l2cap_pdu_pool, pdu);
951: }
952:
953: KASSERT(TAILQ_EMPTY(&link->hl_txq));
954:
955: /* ACL incoming data packet */
956: if (link->hl_rxp != NULL) {
957: m_freem(link->hl_rxp);
958: link->hl_rxp = NULL;
959: }
960:
961: /* SCO master ACL link */
962: if (link->hl_link != NULL) {
963: hci_acl_close(link->hl_link, err);
964: link->hl_link = NULL;
965: }
966:
967: /* SCO pcb */
968: if (link->hl_sco != NULL) {
969: struct sco_pcb *pcb;
970:
971: pcb = link->hl_sco;
972: pcb->sp_link = NULL;
973: link->hl_sco = NULL;
974: (*pcb->sp_proto->disconnected)(pcb->sp_upper, err);
975: }
976:
977: /* flush any SCO data */
978: IF_PURGE(&link->hl_data);
979:
980: /*
981: * Halt the timeout - if its already running we cannot free the
982: * link structure but the timeout function will call us back in
983: * any case.
984: */
985: link->hl_state = HCI_LINK_CLOSED;
986: timeout_del(&link->hl_expire);
987: if (timeout_triggered(&link->hl_expire))
988: return;
989:
990: TAILQ_REMOVE(&link->hl_unit->hci_links, link, hl_next);
991: free(link, M_BLUETOOTH);
992: }
993:
994: /*
995: * Lookup HCI link by type and state.
996: */
997: struct hci_link *
998: hci_link_lookup_state(struct hci_unit *unit, uint16_t type, uint16_t state)
999: {
1000: struct hci_link *link;
1001:
1002: TAILQ_FOREACH(link, &unit->hci_links, hl_next) {
1003: if (link->hl_type == type && link->hl_state == state)
1004: break;
1005: }
1006:
1007: return link;
1008: }
1009:
1010: /*
1011: * Lookup HCI link by address and type. Note that for SCO links there may
1012: * be more than one link per address, so we only return links with no
1013: * handle (ie new links)
1014: */
1015: struct hci_link *
1016: hci_link_lookup_bdaddr(struct hci_unit *unit, bdaddr_t *bdaddr, uint16_t type)
1017: {
1018: struct hci_link *link;
1019:
1020: KASSERT(unit != NULL);
1021: KASSERT(bdaddr != NULL);
1022:
1023: TAILQ_FOREACH(link, &unit->hci_links, hl_next) {
1024: if (link->hl_type != type)
1025: continue;
1026:
1027: if (type == HCI_LINK_SCO && link->hl_handle != 0)
1028: continue;
1029:
1030: if (bdaddr_same(&link->hl_bdaddr, bdaddr))
1031: break;
1032: }
1033:
1034: return link;
1035: }
1036:
1037: struct hci_link *
1038: hci_link_lookup_handle(struct hci_unit *unit, uint16_t handle)
1039: {
1040: struct hci_link *link;
1041:
1042: KASSERT(unit != NULL);
1043:
1044: TAILQ_FOREACH(link, &unit->hci_links, hl_next) {
1045: if (handle == link->hl_handle)
1046: break;
1047: }
1048:
1049: return link;
1050: }