cb721f4391980737c143a18e2ee1feaaa7249e86
[dragonfly.git] / sys / netgraph7 / bluetooth / hci / ng_hci_misc.c
1 /*
2  * ng_hci_misc.c
3  */
4
5 /*-
6  * Copyright (c) Maksim Yevmenkin <m_evmenkin@yahoo.com>
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  *
18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28  * SUCH DAMAGE.
29  *
30  * $Id: ng_hci_misc.c,v 1.5 2003/09/08 18:57:51 max Exp $
31  * $FreeBSD: src/sys/netgraph/bluetooth/hci/ng_hci_misc.c,v 1.10 2005/01/07 01:45:43 imp Exp $
32  */
33
34 #include <sys/param.h>
35 #include <sys/systm.h>
36 #include <sys/kernel.h>
37 #include <sys/malloc.h>
38 #include <sys/mbuf.h>
39 #include <sys/queue.h>
40 #include "ng_message.h"
41 #include "netgraph.h"
42 #include "bluetooth/include/ng_bluetooth.h"
43 #include "bluetooth/include/ng_hci.h"
44 #include "bluetooth/hci/ng_hci_var.h"
45 #include "bluetooth/hci/ng_hci_cmds.h"
46 #include "bluetooth/hci/ng_hci_evnt.h"
47 #include "bluetooth/hci/ng_hci_ulpi.h"
48 #include "bluetooth/hci/ng_hci_misc.h"
49
50 /******************************************************************************
51  ******************************************************************************
52  **                              Utility routines
53  ******************************************************************************
54  ******************************************************************************/
55
56 /*
57  * Give packet to RAW hook
58  * Assumes input mbuf is read only.
59  */
60
61 void
62 ng_hci_mtap(ng_hci_unit_p unit, struct mbuf *m0)
63 {
64         struct mbuf     *m = NULL;
65         int              error = 0;
66
67         if (unit->raw != NULL && NG_HOOK_IS_VALID(unit->raw)) {
68                 m = m_dup(m0, MB_DONTWAIT);
69                 if (m != NULL)
70                         NG_SEND_DATA_ONLY(error, unit->raw, m);
71
72                 if (error != 0)
73                         NG_HCI_INFO(
74 "%s: %s - Could not forward packet, error=%d\n",
75                                 __func__, NG_NODE_NAME(unit->node), error);
76         }
77 } /* ng_hci_mtap */
78
79 /*
80  * Send notification to the upper layer's
81  */
82
83 void
84 ng_hci_node_is_up(node_p node, hook_p hook, void *arg1, int arg2)
85 {
86         ng_hci_unit_p            unit = NULL;
87         struct ng_mesg          *msg = NULL;
88         ng_hci_node_up_ep       *ep = NULL;
89         int                      error;
90
91         if (node == NULL || NG_NODE_NOT_VALID(node) ||
92             hook == NULL || NG_HOOK_NOT_VALID(hook))
93                 return;
94
95         unit = (ng_hci_unit_p) NG_NODE_PRIVATE(node);
96         if ((unit->state & NG_HCI_UNIT_READY) != NG_HCI_UNIT_READY)
97                 return;
98
99         if (hook != unit->acl && hook != unit->sco)
100                 return;
101
102         NG_MKMESSAGE(msg,NGM_HCI_COOKIE,NGM_HCI_NODE_UP,sizeof(*ep),M_WAITOK | M_NULLOK);
103         if (msg != NULL) {
104                 ep = (ng_hci_node_up_ep *)(msg->data);
105
106                 if (hook == unit->acl) {
107                         NG_HCI_BUFF_ACL_SIZE(unit->buffer, ep->pkt_size);
108                         NG_HCI_BUFF_ACL_TOTAL(unit->buffer, ep->num_pkts);
109                 } else {
110                         NG_HCI_BUFF_SCO_SIZE(unit->buffer, ep->pkt_size);
111                         NG_HCI_BUFF_SCO_TOTAL(unit->buffer, ep->num_pkts);
112                 } 
113
114                 bcopy(&unit->bdaddr, &ep->bdaddr, sizeof(ep->bdaddr));
115
116                 NG_SEND_MSG_HOOK(error, node, msg, hook, 0);
117         } else
118                 error = ENOMEM;
119
120         if (error != 0)
121                 NG_HCI_INFO(
122 "%s: %s - failed to send NODE_UP message to hook \"%s\", error=%d\n",
123                         __func__, NG_NODE_NAME(unit->node), 
124                         NG_HOOK_NAME(hook), error);
125 } /* ng_hci_node_is_up */
126
127 /*
128  * Clean unit (helper)
129  */
130
131 void
132 ng_hci_unit_clean(ng_hci_unit_p unit, int reason)
133 {
134         int     size;
135
136         /* Drain command queue */
137         if (unit->state & NG_HCI_UNIT_COMMAND_PENDING)
138                 ng_hci_command_untimeout(unit);
139
140         NG_BT_MBUFQ_DRAIN(&unit->cmdq);
141         NG_HCI_BUFF_CMD_SET(unit->buffer, 1);
142
143         /* Clean up connection list */
144         while (!LIST_EMPTY(&unit->con_list)) {
145                 ng_hci_unit_con_p       con = LIST_FIRST(&unit->con_list);
146
147                 /* Remove all timeouts (if any) */
148                 if (con->flags & NG_HCI_CON_TIMEOUT_PENDING)
149                         ng_hci_con_untimeout(con);
150
151                 /*
152                  * Notify upper layer protocol and destroy connection 
153                  * descriptor. Do not really care about the result.
154                  */
155
156                 ng_hci_lp_discon_ind(con, reason);
157                 ng_hci_free_con(con);
158         }
159
160         NG_HCI_BUFF_ACL_TOTAL(unit->buffer, size);
161         NG_HCI_BUFF_ACL_FREE(unit->buffer, size);
162
163         NG_HCI_BUFF_SCO_TOTAL(unit->buffer, size);
164         NG_HCI_BUFF_SCO_FREE(unit->buffer, size);
165
166         /* Clean up neighbors list */
167         ng_hci_flush_neighbor_cache(unit);
168 } /* ng_hci_unit_clean */
169
170 /*
171  * Allocate and link new unit neighbor cache entry
172  */
173
174 ng_hci_neighbor_p
175 ng_hci_new_neighbor(ng_hci_unit_p unit)
176 {
177         ng_hci_neighbor_p       n = NULL;
178
179         MALLOC(n, ng_hci_neighbor_p, sizeof(*n), M_NETGRAPH_HCI,
180                 M_WAITOK | M_NULLOK | M_ZERO); 
181         if (n != NULL) {
182                 getmicrotime(&n->updated);
183                 LIST_INSERT_HEAD(&unit->neighbors, n, next);
184         }
185
186         return (n);
187 } /* ng_hci_new_neighbor */
188
189 /*
190  * Free unit neighbor cache entry
191  */
192
193 void
194 ng_hci_free_neighbor(ng_hci_neighbor_p n)
195 {
196         LIST_REMOVE(n, next);
197         bzero(n, sizeof(*n));
198         FREE(n, M_NETGRAPH_HCI);
199 } /* ng_hci_free_neighbor */
200
201 /*
202  * Flush neighbor cache 
203  */
204
205 void
206 ng_hci_flush_neighbor_cache(ng_hci_unit_p unit)
207 {
208         while (!LIST_EMPTY(&unit->neighbors))
209                 ng_hci_free_neighbor(LIST_FIRST(&unit->neighbors));
210 } /* ng_hci_flush_neighbor_cache */
211
212 /*
213  * Lookup unit in neighbor cache
214  */
215
216 ng_hci_neighbor_p
217 ng_hci_get_neighbor(ng_hci_unit_p unit, bdaddr_p bdaddr)
218 {
219         ng_hci_neighbor_p       n = NULL;
220
221         for (n = LIST_FIRST(&unit->neighbors); n != NULL; ) {
222                 ng_hci_neighbor_p       nn = LIST_NEXT(n, next);
223
224                 if (!ng_hci_neighbor_stale(n)) {
225                         if (bcmp(&n->bdaddr, bdaddr, sizeof(*bdaddr)) == 0)
226                                 break;
227                 } else 
228                         ng_hci_free_neighbor(n); /* remove old entry */
229
230                 n = nn;
231         }
232         
233         return (n);
234 } /* ng_hci_get_neighbor */
235
236 /*
237  * Check if neighbor entry is stale
238  */
239
240 int
241 ng_hci_neighbor_stale(ng_hci_neighbor_p n)
242 {
243         struct timeval  now;
244
245         getmicrotime(&now);
246
247         return (now.tv_sec - n->updated.tv_sec > bluetooth_hci_max_neighbor_age());
248 } /* ng_hci_neighbor_stale */
249
250 /*
251  * Allocate and link new connection descriptor
252  */
253
254 ng_hci_unit_con_p
255 ng_hci_new_con(ng_hci_unit_p unit, int link_type)
256 {
257         ng_hci_unit_con_p       con = NULL;
258         int                     num_pkts;
259         static int              fake_con_handle = 0x0f00;
260
261         MALLOC(con, ng_hci_unit_con_p, sizeof(*con), M_NETGRAPH_HCI,
262                 M_WAITOK | M_NULLOK | M_ZERO);
263         if (con != NULL) {
264                 con->unit = unit;
265                 con->state = NG_HCI_CON_CLOSED;
266
267                 /*
268                  * XXX
269                  *
270                  * Assign fake connection handle to the connection descriptor.
271                  * Bluetooth specification marks 0x0f00 - 0x0fff connection
272                  * handles as reserved. We need this fake connection handles
273                  * for timeouts. Connection handle will be passed as argument
274                  * to timeout so when timeout happens we can find the right
275                  * connection descriptor. We can not pass pointers, because
276                  * timeouts are external (to Netgraph) events and there might
277                  * be a race when node/hook goes down and timeout event already
278                  * went into node's queue
279                  */
280
281                 con->con_handle = fake_con_handle ++;
282                 if (fake_con_handle > 0x0fff)
283                         fake_con_handle = 0x0f00;
284
285                 con->link_type = link_type;
286
287                 if (con->link_type == NG_HCI_LINK_ACL)
288                         NG_HCI_BUFF_ACL_TOTAL(unit->buffer, num_pkts);
289                 else
290                         NG_HCI_BUFF_SCO_TOTAL(unit->buffer, num_pkts);
291
292                 NG_BT_ITEMQ_INIT(&con->conq, num_pkts);
293
294                 ng_callout_init(&con->con_timo);
295
296                 LIST_INSERT_HEAD(&unit->con_list, con, next);
297         }
298
299         return (con);
300 } /* ng_hci_new_con */
301
302 /*
303  * Free connection descriptor
304  */
305
306 void
307 ng_hci_free_con(ng_hci_unit_con_p con)
308
309         LIST_REMOVE(con, next);
310
311         /*
312          * If we have pending packets then assume that Host Controller has 
313          * flushed these packets and we can free them too
314          */
315
316         if (con->link_type == NG_HCI_LINK_ACL)
317                 NG_HCI_BUFF_ACL_FREE(con->unit->buffer, con->pending);
318         else
319                 NG_HCI_BUFF_SCO_FREE(con->unit->buffer, con->pending);
320
321         NG_BT_ITEMQ_DESTROY(&con->conq);
322
323         bzero(con, sizeof(*con));
324         FREE(con, M_NETGRAPH_HCI);
325 } /* ng_hci_free_con */
326
327 /*
328  * Lookup connection for given unit and connection handle.
329  */
330
331 ng_hci_unit_con_p
332 ng_hci_con_by_handle(ng_hci_unit_p unit, int con_handle)
333 {
334         ng_hci_unit_con_p       con = NULL;
335
336         LIST_FOREACH(con, &unit->con_list, next)
337                 if (con->con_handle == con_handle)
338                         break;
339
340         return (con);
341 } /* ng_hci_con_by_handle */
342
343 /*
344  * Lookup connection for given unit, link type and remove unit address
345  */
346
347 ng_hci_unit_con_p
348 ng_hci_con_by_bdaddr(ng_hci_unit_p unit, bdaddr_p bdaddr, int link_type)
349 {
350         ng_hci_unit_con_p       con = NULL;
351
352         LIST_FOREACH(con, &unit->con_list, next)
353                 if (con->link_type == link_type &&
354                     bcmp(&con->bdaddr, bdaddr, sizeof(bdaddr_t)) == 0)
355                         break;
356
357         return (con);
358 } /* ng_hci_con_by_bdaddr */
359
360 /*
361  * Set HCI command timeout
362  * XXX FIXME: check return code from ng_callout
363  */
364
365 int
366 ng_hci_command_timeout(ng_hci_unit_p unit)
367 {
368         if (unit->state & NG_HCI_UNIT_COMMAND_PENDING)
369                 panic(
370 "%s: %s - Duplicated command timeout!\n", __func__, NG_NODE_NAME(unit->node));
371
372         unit->state |= NG_HCI_UNIT_COMMAND_PENDING;
373         ng_callout(&unit->cmd_timo, unit->node, NULL,
374                                 bluetooth_hci_command_timeout(),
375                                 ng_hci_process_command_timeout, NULL, 0);
376
377         return (0);
378 } /* ng_hci_command_timeout */
379
380 /*
381  * Unset HCI command timeout
382  */
383
384 int
385 ng_hci_command_untimeout(ng_hci_unit_p unit)
386 {
387         if (!(unit->state & NG_HCI_UNIT_COMMAND_PENDING))
388                 panic(
389 "%s: %s - No command timeout!\n", __func__, NG_NODE_NAME(unit->node));
390
391         if (ng_uncallout(&unit->cmd_timo, unit->node) == 0)
392                 return (ETIMEDOUT);
393
394         unit->state &= ~NG_HCI_UNIT_COMMAND_PENDING;
395
396         return (0);
397 } /* ng_hci_command_untimeout */
398
399 /*
400  * Set HCI connection timeout
401  * XXX FIXME: check return code from ng_callout
402  */
403
404 int
405 ng_hci_con_timeout(ng_hci_unit_con_p con)
406 {
407         if (con->flags & NG_HCI_CON_TIMEOUT_PENDING)
408                 panic(
409 "%s: %s - Duplicated connection timeout!\n",
410                         __func__, NG_NODE_NAME(con->unit->node));
411
412         con->flags |= NG_HCI_CON_TIMEOUT_PENDING;
413         ng_callout(&con->con_timo, con->unit->node, NULL,
414                                 bluetooth_hci_connect_timeout(),
415                                 ng_hci_process_con_timeout, NULL,
416                                 con->con_handle);
417
418         return (0);
419 } /* ng_hci_con_timeout */
420
421 /*
422  * Unset HCI connection timeout
423  */
424
425 int
426 ng_hci_con_untimeout(ng_hci_unit_con_p con)
427 {
428         if (!(con->flags & NG_HCI_CON_TIMEOUT_PENDING))
429                 panic(
430 "%s: %s - No connection timeout!\n", __func__, NG_NODE_NAME(con->unit->node));
431
432         if (ng_uncallout(&con->con_timo, con->unit->node) == 0)
433                 return (ETIMEDOUT);
434
435         con->flags &= ~NG_HCI_CON_TIMEOUT_PENDING;
436
437         return (0);
438 } /* ng_hci_con_untimeout */
439
440 #if 0
441 /*
442  * Convert numeric error code/reason to a string
443  */
444
445 char const * const
446 ng_hci_str_error(u_int16_t code)
447 {
448 #define LAST_ERROR_CODE                 (NELEM(s)-1)
449         static char const * const       s[] = {
450         /* 0x00 */ "No error",
451         /* 0x01 */ "Unknown HCI command",
452         /* 0x02 */ "No connection",
453         /* 0x03 */ "Hardware failure",
454         /* 0x04 */ "Page timeout",
455         /* 0x05 */ "Authentication failure",
456         /* 0x06 */ "Key missing",
457         /* 0x07 */ "Memory full",
458         /* 0x08 */ "Connection timeout",
459         /* 0x09 */ "Max number of connections",
460         /* 0x0a */ "Max number of SCO connections to a unit",
461         /* 0x0b */ "ACL connection already exists",
462         /* 0x0c */ "Command disallowed",
463         /* 0x0d */ "Host rejected due to limited resources",
464         /* 0x0e */ "Host rejected due to securiity reasons",
465         /* 0x0f */ "Host rejected due to remote unit is a personal unit",
466         /* 0x10 */ "Host timeout",
467         /* 0x11 */ "Unsupported feature or parameter value",
468         /* 0x12 */ "Invalid HCI command parameter",
469         /* 0x13 */ "Other end terminated connection: User ended connection",
470         /* 0x14 */ "Other end terminated connection: Low resources",
471         /* 0x15 */ "Other end terminated connection: About to power off",
472         /* 0x16 */ "Connection terminated by local host",
473         /* 0x17 */ "Repeated attempts",
474         /* 0x18 */ "Pairing not allowed",
475         /* 0x19 */ "Unknown LMP PDU",
476         /* 0x1a */ "Unsupported remote feature",
477         /* 0x1b */ "SCO offset rejected",
478         /* 0x1c */ "SCO interval rejected",
479         /* 0x1d */ "SCO air mode rejected",
480         /* 0x1e */ "Invalid LMP parameters",
481         /* 0x1f */ "Unspecified error",
482         /* 0x20 */ "Unsupported LMP parameter value",
483         /* 0x21 */ "Role change not allowed",
484         /* 0x22 */ "LMP response timeout",
485         /* 0x23 */ "LMP error transaction collision",
486         /* 0x24 */ "LMP PSU not allowed",
487         /* 0x25 */ "Encryption mode not acceptable",
488         /* 0x26 */ "Unit key used",
489         /* 0x27 */ "QoS is not supported",
490         /* 0x28 */ "Instant passed",
491         /* 0x29 */ "Paring with unit key not supported",
492         /* SHOULD ALWAYS BE LAST */ "Unknown error"
493         };
494
495         return ((code >= LAST_ERROR_CODE)? s[LAST_ERROR_CODE] : s[code]);
496 } /* ng_hci_str_error */
497 #endif
498