root/netbt/sco_upper.c

DEFINITIONS

1. sco_attach
2. sco_bind
3. sco_sockaddr
4. sco_connect
5. sco_peeraddr
6. sco_disconnect
7. sco_detach
8. sco_listen
9. sco_send
10. sco_setopt
11. sco_getopt

    1 /*      $OpenBSD: sco_upper.c,v 1.1 2007/06/01 02:46:12 uwe Exp $       */
    2 /*      $NetBSD: sco_upper.c,v 1.6 2007/03/30 20:47:03 plunky Exp $     */
    4 /*-
    5  * Copyright (c) 2006 Itronix Inc.
    6  * All rights reserved.
    7  *
    8  * Written by Iain Hibbert for Itronix Inc.
    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  */
   35 #include <sys/cdefs.h>
   37 #include <sys/param.h>
   38 #include <sys/kernel.h>
   39 #include <sys/mbuf.h>
   40 #include <sys/proc.h>
   41 #include <sys/systm.h>
   43 #include <netbt/bluetooth.h>
   44 #include <netbt/hci.h>
   45 #include <netbt/sco.h>
   47 /****************************************************************************
   48  *
   49  *      SCO - Upper Protocol API
   50  */
   52 struct sco_pcb_list sco_pcb = LIST_HEAD_INITIALIZER(sco_pcb);
   54 /*
   55  * sco_attach(handle, proto, upper)
   56  *
   57  *      Attach a new instance of SCO pcb to handle
   58  */
   59 int
sco_attach(struct sco_pcb **handle,
   61                 const struct btproto *proto, void *upper)
   62 {
   63         struct sco_pcb *pcb;
KASSERT(handle != NULL);
KASSERT(proto != NULL);
KASSERT(upper != NULL);
pcb = malloc(sizeof(struct sco_pcb), M_BLUETOOTH, M_NOWAIT);
   70         if (pcb == NULL)
   71                 return ENOMEM;
bzero(pcb, sizeof *pcb);
pcb->sp_proto = proto;
pcb->sp_upper = upper;
LIST_INSERT_HEAD(&sco_pcb, pcb, sp_next);
   79         *handle = pcb;
   80         return 0;
   81 }
   83 /*
   84  * sco_bind(pcb, sockaddr)
   85  *
   86  *      Bind SCO pcb to local address
   87  */
   88 int
sco_bind(struct sco_pcb *pcb, struct sockaddr_bt *addr)
   90 {
bdaddr_copy(&pcb->sp_laddr, &addr->bt_bdaddr);
   93         return 0;
   94 }
   96 /*
   97  * sco_sockaddr(pcb, sockaddr)
   98  *
   99  *      Copy local address of PCB to sockaddr
  100  */
  101 int
sco_sockaddr(struct sco_pcb *pcb, struct sockaddr_bt *addr)
  103 {
memset(addr, 0, sizeof(struct sockaddr_bt));
addr->bt_len = sizeof(struct sockaddr_bt);
addr->bt_family = AF_BLUETOOTH;
bdaddr_copy(&addr->bt_bdaddr, &pcb->sp_laddr);
  109         return 0;
  110 }
  112 /*
  113  * sco_connect(pcb, sockaddr)
  114  *
  115  *      Initiate a SCO connection to the destination address.
  116  */
  117 int
sco_connect(struct sco_pcb *pcb, struct sockaddr_bt *dest)
  119 {
hci_add_sco_con_cp cp;
  121         struct hci_unit *unit;
  122         struct hci_link *acl, *sco;
  123         int err;
  125         if (pcb->sp_flags & SP_LISTENING)
  126                 return EINVAL;
bdaddr_copy(&pcb->sp_raddr, &dest->bt_bdaddr);
  130         if (bdaddr_any(&pcb->sp_raddr))
  131                 return EDESTADDRREQ;
  133         if (bdaddr_any(&pcb->sp_laddr)) {
err = hci_route_lookup(&pcb->sp_laddr, &pcb->sp_raddr);
  135                 if (err)
  136                         return err;
  137         }
unit = hci_unit_lookup(&pcb->sp_laddr);
  140         if (unit == NULL)
  141                 return ENETDOWN;
  143         /*
  144          * We must have an already open ACL connection before we open the SCO
  145          * connection, and since SCO connections dont happen on their own we
  146          * will not open one, the application wanting this should have opened
  147          * it previously.
  148          */
acl = hci_link_lookup_bdaddr(unit, &pcb->sp_raddr, HCI_LINK_ACL);
  150         if (acl == NULL || acl->hl_state != HCI_LINK_OPEN)
  151                 return EHOSTUNREACH;
sco = hci_link_alloc(unit);
  154         if (sco == NULL)
  155                 return ENOMEM;
sco->hl_type = HCI_LINK_SCO;
bdaddr_copy(&sco->hl_bdaddr, &pcb->sp_raddr);
sco->hl_link = hci_acl_open(unit, &pcb->sp_raddr);
KASSERT(sco->hl_link == acl);
cp.con_handle = htole16(acl->hl_handle);
cp.pkt_type = htole16(0x00e0);          /* HV1, HV2, HV3 */
err = hci_send_cmd(unit, HCI_CMD_ADD_SCO_CON, &cp, sizeof(cp));
  166         if (err) {
hci_link_free(sco, err);
  168                 return err;
  169         }
sco->hl_sco = pcb;
pcb->sp_link = sco;
pcb->sp_mtu = unit->hci_max_sco_size;
  175         return 0;
  176 }
  178 /*
  179  * sco_peeraddr(pcb, sockaddr)
  180  *
  181  *      Copy remote address of SCO pcb to sockaddr
  182  */
  183 int
sco_peeraddr(struct sco_pcb *pcb, struct sockaddr_bt *addr)
  185 {
memset(addr, 0, sizeof(struct sockaddr_bt));
addr->bt_len = sizeof(struct sockaddr_bt);
addr->bt_family = AF_BLUETOOTH;
bdaddr_copy(&addr->bt_bdaddr, &pcb->sp_raddr);
  191         return 0;
  192 }
  194 /*
  195  * sco_disconnect(pcb, linger)
  196  *
  197  *      Initiate disconnection of connected SCO pcb
  198  */
  199 int
sco_disconnect(struct sco_pcb *pcb, int linger)
  201 {
hci_discon_cp cp;
  203         struct hci_link *sco;
  204         int err;
sco = pcb->sp_link;
  207         if (sco == NULL)
  208                 return EINVAL;
cp.con_handle = htole16(sco->hl_handle);
cp.reason = 0x13;       /* "Remote User Terminated Connection" */
err = hci_send_cmd(sco->hl_unit, HCI_CMD_DISCONNECT, &cp, sizeof(cp));
  214         if (err || linger == 0) {
sco->hl_sco = NULL;
pcb->sp_link = NULL;
hci_link_free(sco, err);
  218         }
  220         return err;
  221 }
  223 /*
  224  * sco_detach(handle)
  225  *
  226  *      Detach SCO pcb from handle and clear up
  227  */
  228 int
sco_detach(struct sco_pcb **handle)
  230 {
  231         struct sco_pcb *pcb;
KASSERT(handle != NULL);
pcb = *handle;
  235         *handle = NULL;
  237         if (pcb == NULL)
  238                 return EINVAL;
  240         if (pcb->sp_link != NULL) {
sco_disconnect(pcb, 0);
pcb->sp_link = NULL;
  243         }
LIST_REMOVE(pcb, sp_next);
free(pcb, M_BLUETOOTH);
  247         return 0;
  248 }
  250 /*
  251  * sco_listen(pcb)
  252  *
  253  *      Mark pcb as a listener.
  254  */
  255 int
sco_listen(struct sco_pcb *pcb)
  257 {
  259         if (pcb->sp_link != NULL)
  260                 return EINVAL;
pcb->sp_flags |= SP_LISTENING;
  263         return 0;
  264 }
  266 /*
  267  * sco_send(pcb, mbuf)
  268  *
  269  *      Send data on SCO pcb.
  270  *
  271  * Gross hackage, we just output the packet directly onto the unit queue.
  272  * This will work fine for one channel per unit, but for more channels it
  273  * really needs fixing. We set the context so that when the packet is sent,
  274  * we can drop a record from the socket buffer.
  275  */
  276 int
sco_send(struct sco_pcb *pcb, struct mbuf *m)
  278 {
hci_scodata_hdr_t *hdr;
  280         int plen;
  282         if (pcb->sp_link == NULL) {
m_freem(m);
  284                 return EINVAL;
  285         }
plen = m->m_pkthdr.len;
DPRINTFN(10, "%d bytes\n", plen);
  290         /*
  291          * This is a temporary limitation, as USB devices cannot
  292          * handle SCO packet sizes that are not an integer number
  293          * of Isochronous frames. See ubt(4)
  294          */
  295         if (plen != pcb->sp_mtu) {
m_freem(m);
  297                 return EMSGSIZE;
  298         }
M_PREPEND(m, sizeof(hci_scodata_hdr_t), M_DONTWAIT);
  301         if (m == NULL)
  302                 return ENOMEM;
hdr = mtod(m, hci_scodata_hdr_t *);
hdr->type = HCI_SCO_DATA_PKT;
hdr->con_handle = htole16(pcb->sp_link->hl_handle);
hdr->length = plen;
pcb->sp_pending++;
M_SETCTX(m, pcb->sp_link);
hci_output_sco(pcb->sp_link->hl_unit, m);
  313         return 0;
  314 }
  316 /*
  317  * sco_setopt(pcb, option, addr)
  318  *
  319  *      Set SCO pcb options
  320  */
  321 int
sco_setopt(struct sco_pcb *pcb, int opt, void *addr)
  323 {
  324         int err = 0;
  326         switch (opt) {
  327         default:
err = ENOPROTOOPT;
  329                 break;
  330         }
  332         return err;
  333 }
  335 /*
  336  * sco_getopt(pcb, option, addr)
  337  *
  338  *      Get SCO pcb options
  339  */
  340 int
sco_getopt(struct sco_pcb *pcb, int opt, void *addr)
  342 {
  344         switch (opt) {
  345         case SO_SCO_MTU:
  346                 *(uint16_t *)addr = pcb->sp_mtu;
  347                 return sizeof(uint16_t);
  349         case SO_SCO_HANDLE:
  350                 if (pcb->sp_link) {
  351                         *(uint16_t *)addr = pcb->sp_link->hl_handle;
  352                         return sizeof(uint16_t);
  353                 }
  354                 break;
  356         default:
  357                 break;
  358         }
  359         return 0;
  360 }