Remove some duplicated semicolons (mostly in the kernel).
[dragonfly.git] / sys / netbt / l2cap_misc.c
1 /* $OpenBSD: src/sys/netbt/l2cap_misc.c,v 1.3 2008/02/24 21:34:48 uwe Exp $ */
2 /* $NetBSD: l2cap_misc.c,v 1.5 2007/11/03 17:20:17 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/param.h>
35 #include <sys/kernel.h>
36 #include <sys/mbuf.h>
37 #include <sys/proc.h>
38 #include <sys/queue.h>
39 #include <sys/systm.h>
40 #include <net/if.h>
41
42 #include <netbt/bluetooth.h>
43 #include <netbt/hci.h>
44 #include <netbt/l2cap.h>
45
46 struct l2cap_channel_list
47         l2cap_active_list = LIST_HEAD_INITIALIZER(l2cap_active_list);
48 struct l2cap_channel_list
49         l2cap_listen_list = LIST_HEAD_INITIALIZER(l2cap_listen_list);
50
51 vm_zone_t l2cap_req_pool;
52 vm_zone_t l2cap_pdu_pool;
53
54 const l2cap_qos_t l2cap_default_qos = {
55         0,                      /* flags */
56         L2CAP_QOS_BEST_EFFORT,  /* service type */
57         0x00000000,             /* token rate */
58         0x00000000,             /* token bucket size */
59         0x00000000,             /* peak bandwidth */
60         0xffffffff,             /* latency */
61         0xffffffff              /* delay variation */
62 };
63
64 /*
65  * L2CAP request timeouts
66  */
67 int l2cap_response_timeout = 30;                /* seconds */
68 int l2cap_response_extended_timeout = 180;      /* seconds */
69
70 void
71 l2cap_init(void)
72 {
73 }
74
75 /*
76  * Set Link Mode on channel
77  */
78 int
79 l2cap_setmode(struct l2cap_channel *chan)
80 {
81         KKASSERT(chan != NULL);
82         KKASSERT(chan->lc_link != NULL);
83
84         DPRINTF("(%s) CID #%d, auth %s, encrypt %s, secure %s\n",
85             device_get_nameunit(chan->lc_link->hl_unit->hci_dev), chan->lc_lcid,
86             (chan->lc_mode & L2CAP_LM_AUTH ? "yes" : "no"),
87             (chan->lc_mode & L2CAP_LM_ENCRYPT ? "yes" : "no"),
88             (chan->lc_mode & L2CAP_LM_SECURE ? "yes" : "no"));
89
90         if (chan->lc_mode & L2CAP_LM_AUTH)
91                 chan->lc_link->hl_flags |= HCI_LINK_AUTH_REQ;
92
93         if (chan->lc_mode & L2CAP_LM_ENCRYPT)
94                 chan->lc_link->hl_flags |= HCI_LINK_ENCRYPT_REQ;
95
96         if (chan->lc_mode & L2CAP_LM_SECURE)
97                 chan->lc_link->hl_flags |= HCI_LINK_SECURE_REQ;
98
99         return hci_acl_setmode(chan->lc_link);
100 }
101
102 /*
103  * Allocate a new Request structure & ID and set the timer going
104  */
105 int
106 l2cap_request_alloc(struct l2cap_channel *chan, uint8_t code)
107 {
108         struct hci_link *link = chan->lc_link;
109         struct l2cap_req *req;
110         int next_id;
111
112         if (link == NULL)
113                 return ENETDOWN;
114
115         /* find next ID (0 is not allowed) */
116         next_id = link->hl_lastid + 1;
117         if (next_id > 0xff)
118                 next_id = 1;
119
120         /* Ouroboros check */
121         req = TAILQ_FIRST(&link->hl_reqs);
122         if (req && req->lr_id == next_id)
123                 return ENFILE;
124
125         req = zalloc(l2cap_req_pool);
126         if (req == NULL)
127                 return ENOMEM;
128
129         req->lr_id = link->hl_lastid = next_id;
130
131         req->lr_code = code;
132         req->lr_chan = chan;
133         req->lr_link = link;
134
135         callout_init(&req->lr_rtx);
136         callout_reset(&req->lr_rtx, l2cap_response_timeout * hz,
137             l2cap_rtx, req);
138
139         TAILQ_INSERT_TAIL(&link->hl_reqs, req, lr_next);
140
141         return 0;
142 }
143
144 /*
145  * Find a running request for this link
146  */
147 struct l2cap_req *
148 l2cap_request_lookup(struct hci_link *link, uint8_t id)
149 {
150         struct l2cap_req *req;
151
152         TAILQ_FOREACH(req, &link->hl_reqs, lr_next) {
153                 if (req->lr_id == id)
154                         return req;
155         }
156
157         return NULL;
158 }
159
160 /*
161  * Halt and free a request
162  */
163 void
164 l2cap_request_free(struct l2cap_req *req)
165 {
166         struct hci_link *link = req->lr_link;
167
168         callout_stop(&req->lr_rtx);
169         if (callout_active(&req->lr_rtx))
170                 return;
171
172         TAILQ_REMOVE(&link->hl_reqs, req, lr_next);
173         zfree(l2cap_req_pool, req);
174 }
175
176 /*
177  * Response Timeout eXpired
178  *
179  * No response to our request, so deal with it as best we can.
180  *
181  * XXX should try again at least with ertx?
182  */
183 void
184 l2cap_rtx(void *arg)
185 {
186         struct l2cap_req *req = arg;
187         struct l2cap_channel *chan;
188
189         chan = req->lr_chan;
190         l2cap_request_free(req);
191
192         DPRINTF("cid %d, ident %d\n", (chan ? chan->lc_lcid : 0), req->lr_id);
193
194         if (chan && chan->lc_state != L2CAP_CLOSED)
195                 l2cap_close(chan, ETIMEDOUT);
196
197 }
198
199 /*
200  * Allocate next available CID to channel. We keep a single
201  * ordered list of channels, so find the first gap.
202  *
203  * If this turns out to be not enough (!), could use a
204  * list per HCI unit..
205  */
206 int
207 l2cap_cid_alloc(struct l2cap_channel *chan)
208 {
209         struct l2cap_channel *used, *prev = NULL;
210         uint16_t cid = L2CAP_FIRST_CID;
211
212         if (chan->lc_lcid != L2CAP_NULL_CID || chan->lc_state != L2CAP_CLOSED)
213                 return EISCONN;
214
215         LIST_FOREACH(used, &l2cap_active_list, lc_ncid) {
216                 if (used->lc_lcid > cid)
217                         break;  /* found our gap */
218
219                 KKASSERT(used->lc_lcid == cid);
220                 cid++;
221
222                 if (cid == L2CAP_LAST_CID)
223                         return ENFILE;
224
225                 prev = used;    /* for insert after */
226         }
227
228         chan->lc_lcid = cid;
229
230         if (prev)
231                 LIST_INSERT_AFTER(prev, chan, lc_ncid);
232         else
233                 LIST_INSERT_HEAD(&l2cap_active_list, chan, lc_ncid);
234
235         return 0;
236 }
237
238 /*
239  * Find channel with CID
240  */
241 struct l2cap_channel *
242 l2cap_cid_lookup(uint16_t cid)
243 {
244         struct l2cap_channel *chan;
245
246         LIST_FOREACH(chan, &l2cap_active_list, lc_ncid) {
247                 if (chan->lc_lcid == cid)
248                         return chan;
249
250                 if (chan->lc_lcid > cid)
251                         return NULL;
252         }
253
254         return NULL;
255 }