root/netbt/hci_unit.c

DEFINITIONS

1. hci_attach
2. hci_detach
3. hci_enable
4. hci_disable
5. hci_unit_lookup
6. hci_send_cmd
7. hci_intr
8. hci_input_event
9. hci_input_acl
10. hci_input_sco
11. hci_output_cmd
12. hci_output_acl
13. hci_output_sco
14. hci_complete_sco

    1 /*      $OpenBSD: hci_unit.c,v 1.7 2007/06/24 20:55:27 uwe Exp $        */
    2 /*      $NetBSD: hci_unit.c,v 1.4 2007/03/30 20:47:03 plunky Exp $      */
    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  */
   34 #include <sys/cdefs.h>
   36 #include <sys/param.h>
   37 #include <sys/conf.h>
   38 #include <sys/device.h>
   39 #include <sys/kernel.h>
   40 #include <sys/malloc.h>
   41 #include <sys/mbuf.h>
   42 #include <sys/proc.h>
   43 #include <sys/queue.h>
   44 #include <sys/systm.h>
   46 #include <net/netisr.h>
   48 #include <netbt/bluetooth.h>
   49 #include <netbt/hci.h>
   51 struct hci_unit_list hci_unit_list = TAILQ_HEAD_INITIALIZER(hci_unit_list);
   53 /*
   54  * HCI Input Queue max lengths.
   55  */
   56 int hci_eventq_max = 20;
   57 int hci_aclrxq_max = 50;
   58 int hci_scorxq_max = 50;
   60 /*
   61  * bluetooth unit functions
   62  */
   64 void
hci_attach(struct hci_unit *unit)
   66 {
KASSERT(unit->hci_softc != NULL);
KASSERT(unit->hci_devname != NULL);
KASSERT(unit->hci_enable != NULL);
KASSERT(unit->hci_disable != NULL);
KASSERT(unit->hci_start_cmd != NULL);
KASSERT(unit->hci_start_acl != NULL);
KASSERT(unit->hci_start_sco != NULL);
unit->hci_eventq.ifq_maxlen = hci_eventq_max;
unit->hci_aclrxq.ifq_maxlen = hci_aclrxq_max;
unit->hci_scorxq.ifq_maxlen = hci_scorxq_max;
TAILQ_INIT(&unit->hci_links);
LIST_INIT(&unit->hci_memos);
TAILQ_INSERT_TAIL(&hci_unit_list, unit, hci_next);
   83 }
   85 void
hci_detach(struct hci_unit *unit)
   87 {
hci_disable(unit);
TAILQ_REMOVE(&hci_unit_list, unit, hci_next);
   91 }
   93 int
hci_enable(struct hci_unit *unit)
   95 {
   96         int s, err;
   98         /*
   99          * Bluetooth spec says that a device can accept one
  100          * command on power up until they send a Command Status
  101          * or Command Complete event with more information, but
  102          * it seems that some devices cant and prefer to send a
  103          * No-op Command Status packet when they are ready, so
  104          * we set this here and allow the driver (bt3c) to zero
  105          * it.
  106          */
unit->hci_num_cmd_pkts = 1;
unit->hci_num_acl_pkts = 0;
unit->hci_num_sco_pkts = 0;
  111         /*
  112          * only allow the basic packet types until
  113          * the features report is in
  114          */
unit->hci_acl_mask = HCI_PKT_DM1 | HCI_PKT_DH1;
unit->hci_packet_type = unit->hci_acl_mask;
s = splraiseipl(unit->hci_ipl);
err = (*unit->hci_enable)(unit);
splx(s);
  121         if (err)
  122                 goto bad1;
  124         /*
  125          * Reset the device, this will trigger initialisation
  126          * and wake us up.
  127          */
unit->hci_flags |= BTF_INIT;
err = hci_send_cmd(unit, HCI_CMD_RESET, NULL, 0);
  131         if (err)
  132                 goto bad2;
  134         while (unit->hci_flags & BTF_INIT) {
err = tsleep(unit, PWAIT | PCATCH, __func__, 5 * hz);
  136                 if (err)
  137                         goto bad2;
  139                 /* XXX
  140                  * "What If", while we were sleeping, the device
  141                  * was removed and detached? Ho Hum.
  142                  */
  143         }
  145         /*
  146          * Attach Bluetooth Device Hub
  147          */
unit->hci_bthub = config_found(unit->hci_softc,
  149             &unit->hci_bdaddr, NULL);
  151         return 0;
bad2:
s = splraiseipl(unit->hci_ipl);
  155         (*unit->hci_disable)(unit);
splx(s);
bad1:
  159         return err;
  160 }
  162 void
hci_disable(struct hci_unit *unit)
  164 {
  165         struct hci_link *link, *next;
  166         struct hci_memo *memo;
  167         int s, acl;
  169         if (unit->hci_bthub) {
config_detach(unit->hci_bthub, DETACH_FORCE);
unit->hci_bthub = NULL;
  172         }
s = splraiseipl(unit->hci_ipl);
  175         (*unit->hci_disable)(unit);
splx(s);
  178         /*
  179          * close down any links, take care to close SCO first since
  180          * they may depend on ACL links.
  181          */
  182         for (acl = 0 ; acl < 2 ; acl++) {
next = TAILQ_FIRST(&unit->hci_links);
  184                 while ((link = next) != NULL) {
next = TAILQ_NEXT(link, hl_next);
  186                         if (acl || link->hl_type != HCI_LINK_ACL)
hci_link_free(link, ECONNABORTED);
  188                 }
  189         }
  191         while ((memo = LIST_FIRST(&unit->hci_memos)) != NULL)
hci_memo_free(memo);
IF_PURGE(&unit->hci_eventq);
unit->hci_eventqlen = 0;
IF_PURGE(&unit->hci_aclrxq);
unit->hci_aclrxqlen = 0;
IF_PURGE(&unit->hci_scorxq);
unit->hci_scorxqlen = 0;
IF_PURGE(&unit->hci_cmdq);
IF_PURGE(&unit->hci_cmdwait);
IF_PURGE(&unit->hci_acltxq);
IF_PURGE(&unit->hci_scotxq);
IF_PURGE(&unit->hci_scodone);
  208 }
  210 struct hci_unit *
hci_unit_lookup(bdaddr_t *addr)
  212 {
  213         struct hci_unit *unit;
TAILQ_FOREACH(unit, &hci_unit_list, hci_next) {
  216                 if ((unit->hci_flags & BTF_UP) == 0)
  217                         continue;
  219                 if (bdaddr_same(&unit->hci_bdaddr, addr))
  220                         break;
  221         }
  223         return unit;
  224 }
  226 /*
  227  * construct and queue a HCI command packet
  228  */
  229 int
hci_send_cmd(struct hci_unit *unit, uint16_t opcode, void *buf, uint8_t len)
  231 {
  232         struct mbuf *m;
hci_cmd_hdr_t *p;
KASSERT(unit != NULL);
m = m_gethdr(M_DONTWAIT, MT_DATA);
  238         if (m == NULL)
  239                 return ENOMEM;
p = mtod(m, hci_cmd_hdr_t *);
p->type = HCI_CMD_PKT;
p->opcode = htole16(opcode);
p->length = len;
m->m_pkthdr.len = m->m_len = sizeof(hci_cmd_hdr_t);
M_SETCTX(m, NULL);
  248         if (len) {
KASSERT(buf != NULL);
m_copyback(m, sizeof(hci_cmd_hdr_t), len, buf);
  252                 if (m->m_pkthdr.len != (sizeof(hci_cmd_hdr_t) + len)) {
m_freem(m);
  254                         return ENOMEM;
  255                 }
  256         }
DPRINTFN(2, "(%s) opcode (%3.3x|%4.4x)\n", unit->hci_devname,
HCI_OGF(opcode), HCI_OCF(opcode));
  261         /* and send it on */
  262         if (unit->hci_num_cmd_pkts == 0)
IF_ENQUEUE(&unit->hci_cmdwait, m);
  264         else
hci_output_cmd(unit, m);
  267         return 0;
  268 }
  270 /*
  271  * Incoming packet processing. Since the code is single threaded
  272  * in any case (IPL_SOFTNET), we handle it all in one interrupt function
  273  * picking our way through more important packets first so that hopefully
  274  * we will never get clogged up with bulk data.
  275  */
  276 void
hci_intr(void *arg)
  278 {
  279         struct hci_unit *unit = arg;
  280         struct mbuf *m;
  281         int s;
another:
s = splraiseipl(unit->hci_ipl);
  286         if (unit->hci_eventqlen > 0) {
IF_DEQUEUE(&unit->hci_eventq, m);
unit->hci_eventqlen--;
KASSERT(m != NULL);
splx(s);
DPRINTFN(10, "(%s) recv event, len = %d\n",
unit->hci_devname, m->m_pkthdr.len);
m->m_flags |= M_LINK0;  /* mark incoming packet */
hci_mtap(m, unit);
hci_event(m, unit);
  299                 goto another;
  300         }
  302         if (unit->hci_scorxqlen > 0) {
IF_DEQUEUE(&unit->hci_scorxq, m);
unit->hci_scorxqlen--;
KASSERT(m != NULL);
splx(s);
DPRINTFN(10, "(%s) recv SCO, len = %d\n",
unit->hci_devname, m->m_pkthdr.len);
m->m_flags |= M_LINK0;  /* mark incoming packet */
hci_mtap(m, unit);
hci_sco_recv(m, unit);
  315                 goto another;
  316         }
  318         if (unit->hci_aclrxqlen > 0) {
IF_DEQUEUE(&unit->hci_aclrxq, m);
unit->hci_aclrxqlen--;
KASSERT(m != NULL);
splx(s);
DPRINTFN(10, "(%s) recv ACL, len = %d\n",
unit->hci_devname, m->m_pkthdr.len);
m->m_flags |= M_LINK0;  /* mark incoming packet */
hci_mtap(m, unit);
hci_acl_recv(m, unit);
  331                 goto another;
  332         }
IF_DEQUEUE(&unit->hci_scodone, m);
  335         if (m != NULL) {
  336                 struct hci_link *link;
splx(s);
DPRINTFN(11, "(%s) complete SCO\n",
unit->hci_devname);
TAILQ_FOREACH(link, &unit->hci_links, hl_next) {
  343                         if (link == M_GETCTX(m, struct hci_link *)) {
hci_sco_complete(link, 1);
  345                                 break;
  346                         }
  347                 }
unit->hci_num_sco_pkts++;
m_freem(m);
  352                 goto another;
  353         }
splx(s);
DPRINTFN(10, "done\n");
  358 }
  360 /**********************************************************************
  361  *
  362  * IO routines
  363  *
  364  * input & complete routines will be called from device driver
  365  * (at unit->hci_ipl)
  366  */
  368 void
hci_input_event(struct hci_unit *unit, struct mbuf *m)
  370 {
  371         if (unit->hci_eventqlen > hci_eventq_max) {
DPRINTF("(%s) dropped event packet.\n", unit->hci_devname);
unit->hci_stats.err_rx++;
m_freem(m);
  375         } else {
unit->hci_eventqlen++;
IF_ENQUEUE(&unit->hci_eventq, m);
schednetisr(NETISR_BT);
  379         }
  380 }
  382 void
hci_input_acl(struct hci_unit *unit, struct mbuf *m)
  384 {
  385         if (unit->hci_aclrxqlen > hci_aclrxq_max) {
DPRINTF("(%s) dropped ACL packet.\n", unit->hci_devname);
unit->hci_stats.err_rx++;
m_freem(m);
  389         } else {
unit->hci_aclrxqlen++;
IF_ENQUEUE(&unit->hci_aclrxq, m);
schednetisr(NETISR_BT);
  393         }
  394 }
  396 void
hci_input_sco(struct hci_unit *unit, struct mbuf *m)
  398 {
  399         if (unit->hci_scorxqlen > hci_scorxq_max) {
DPRINTF("(%s) dropped SCO packet.\n", unit->hci_devname);
unit->hci_stats.err_rx++;
m_freem(m);
  403         } else {
unit->hci_scorxqlen++;
IF_ENQUEUE(&unit->hci_scorxq, m);
schednetisr(NETISR_BT);
  407         }
  408 }
  410 void
hci_output_cmd(struct hci_unit *unit, struct mbuf *m)
  412 {
  413         void *arg;
  414         int s;
hci_mtap(m, unit);
DPRINTFN(10, "(%s) num_cmd_pkts=%d\n", unit->hci_devname,
unit->hci_num_cmd_pkts);
unit->hci_num_cmd_pkts--;
  423         /*
  424          * If context is set, this was from a HCI raw socket
  425          * and a record needs to be dropped from the sockbuf.
  426          */
arg = M_GETCTX(m, void *);
  428         if (arg != NULL)
hci_drop(arg);
s = splraiseipl(unit->hci_ipl);
IF_ENQUEUE(&unit->hci_cmdq, m);
  433         if ((unit->hci_flags & BTF_XMIT_CMD) == 0)
  434                 (*unit->hci_start_cmd)(unit);
splx(s);
  437 }
  439 void
hci_output_acl(struct hci_unit *unit, struct mbuf *m)
  441 {
  442         int s;
hci_mtap(m, unit);
DPRINTFN(10, "(%s) num_acl_pkts=%d\n", unit->hci_devname,
unit->hci_num_acl_pkts);
unit->hci_num_acl_pkts--;
s = splraiseipl(unit->hci_ipl);
IF_ENQUEUE(&unit->hci_acltxq, m);
  453         if ((unit->hci_flags & BTF_XMIT_ACL) == 0)
  454                 (*unit->hci_start_acl)(unit);
splx(s);
  457 }
  459 void
hci_output_sco(struct hci_unit *unit, struct mbuf *m)
  461 {
  462         int s;
hci_mtap(m, unit);
DPRINTFN(10, "(%s) num_sco_pkts=%d\n", unit->hci_devname,
unit->hci_num_sco_pkts);
unit->hci_num_sco_pkts--;
s = splraiseipl(unit->hci_ipl);
IF_ENQUEUE(&unit->hci_scotxq, m);
  473         if ((unit->hci_flags & BTF_XMIT_SCO) == 0)
  474                 (*unit->hci_start_sco)(unit);
splx(s);
  477 }
  479 void
hci_complete_sco(struct hci_unit *unit, struct mbuf *m)
  481 {
IF_ENQUEUE(&unit->hci_scodone, m);
schednetisr(NETISR_BT);
  484 }