1 /* $OpenBSD: sco_upper.c,v 1.2 2007/10/01 16:39:30 krw Exp $ */ 2 /* $NetBSD: sco_upper.c,v 1.6 2007/03/30 20:47:03 plunky Exp $ */ 3 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 */ 34 35 #include <sys/param.h> 36 #include <sys/kernel.h> 37 #include <sys/mbuf.h> 38 #include <sys/proc.h> 39 #include <sys/systm.h> 40 #include <sys/endian.h> 41 #include <sys/bus.h> 42 43 #include <netbt/bluetooth.h> 44 #include <netbt/hci.h> 45 #include <netbt/sco.h> 46 47 /**************************************************************************** 48 * 49 * SCO - Upper Protocol API 50 */ 51 52 struct sco_pcb_list sco_pcb = LIST_HEAD_INITIALIZER(sco_pcb); 53 54 /* 55 * sco_attach(handle, proto, upper) 56 * 57 * Attach a new instance of SCO pcb to handle 58 */ 59 int 60 sco_attach(struct sco_pcb **handle, 61 const struct btproto *proto, void *upper) 62 { 63 struct sco_pcb *pcb; 64 65 KKASSERT(handle != NULL); 66 KKASSERT(proto != NULL); 67 KKASSERT(upper != NULL); 68 69 pcb = kmalloc(sizeof(*pcb), M_BLUETOOTH, M_NOWAIT | M_ZERO); 70 if (pcb == NULL) 71 return ENOMEM; 72 73 pcb->sp_proto = proto; 74 pcb->sp_upper = upper; 75 76 LIST_INSERT_HEAD(&sco_pcb, pcb, sp_next); 77 78 *handle = pcb; 79 return 0; 80 } 81 82 /* 83 * sco_bind(pcb, sockaddr) 84 * 85 * Bind SCO pcb to local address 86 */ 87 int 88 sco_bind(struct sco_pcb *pcb, struct sockaddr_bt *addr) 89 { 90 91 bdaddr_copy(&pcb->sp_laddr, &addr->bt_bdaddr); 92 return 0; 93 } 94 95 /* 96 * sco_sockaddr(pcb, sockaddr) 97 * 98 * Copy local address of PCB to sockaddr 99 */ 100 int 101 sco_sockaddr(struct sco_pcb *pcb, struct sockaddr_bt *addr) 102 { 103 104 memset(addr, 0, sizeof(struct sockaddr_bt)); 105 addr->bt_len = sizeof(struct sockaddr_bt); 106 addr->bt_family = AF_BLUETOOTH; 107 bdaddr_copy(&addr->bt_bdaddr, &pcb->sp_laddr); 108 return 0; 109 } 110 111 /* 112 * sco_connect(pcb, sockaddr) 113 * 114 * Initiate a SCO connection to the destination address. 115 */ 116 int 117 sco_connect(struct sco_pcb *pcb, struct sockaddr_bt *dest) 118 { 119 hci_add_sco_con_cp cp; 120 struct hci_unit *unit; 121 struct hci_link *acl, *sco; 122 int err; 123 124 if (pcb->sp_flags & SP_LISTENING) 125 return EINVAL; 126 127 bdaddr_copy(&pcb->sp_raddr, &dest->bt_bdaddr); 128 129 if (bdaddr_any(&pcb->sp_raddr)) 130 return EDESTADDRREQ; 131 132 if (bdaddr_any(&pcb->sp_laddr)) { 133 err = hci_route_lookup(&pcb->sp_laddr, &pcb->sp_raddr); 134 if (err) 135 return err; 136 } 137 138 unit = hci_unit_lookup(&pcb->sp_laddr); 139 if (unit == NULL) 140 return ENETDOWN; 141 142 /* 143 * We must have an already open ACL connection before we open the SCO 144 * connection, and since SCO connections dont happen on their own we 145 * will not open one, the application wanting this should have opened 146 * it previously. 147 */ 148 acl = hci_link_lookup_bdaddr(unit, &pcb->sp_raddr, HCI_LINK_ACL); 149 if (acl == NULL || acl->hl_state != HCI_LINK_OPEN) 150 return EHOSTUNREACH; 151 152 sco = hci_link_alloc(unit); 153 if (sco == NULL) 154 return ENOMEM; 155 156 sco->hl_type = HCI_LINK_SCO; 157 bdaddr_copy(&sco->hl_bdaddr, &pcb->sp_raddr); 158 159 sco->hl_link = hci_acl_open(unit, &pcb->sp_raddr); 160 KKASSERT(sco->hl_link == acl); 161 162 cp.con_handle = htole16(acl->hl_handle); 163 cp.pkt_type = htole16(0x00e0); /* HV1, HV2, HV3 */ 164 err = hci_send_cmd(unit, HCI_CMD_ADD_SCO_CON, &cp, sizeof(cp)); 165 if (err) { 166 hci_link_free(sco, err); 167 return err; 168 } 169 170 sco->hl_sco = pcb; 171 pcb->sp_link = sco; 172 173 pcb->sp_mtu = unit->hci_max_sco_size; 174 return 0; 175 } 176 177 /* 178 * sco_peeraddr(pcb, sockaddr) 179 * 180 * Copy remote address of SCO pcb to sockaddr 181 */ 182 int 183 sco_peeraddr(struct sco_pcb *pcb, struct sockaddr_bt *addr) 184 { 185 186 memset(addr, 0, sizeof(struct sockaddr_bt)); 187 addr->bt_len = sizeof(struct sockaddr_bt); 188 addr->bt_family = AF_BLUETOOTH; 189 bdaddr_copy(&addr->bt_bdaddr, &pcb->sp_raddr); 190 return 0; 191 } 192 193 /* 194 * sco_disconnect(pcb, linger) 195 * 196 * Initiate disconnection of connected SCO pcb 197 */ 198 int 199 sco_disconnect(struct sco_pcb *pcb, int linger) 200 { 201 hci_discon_cp cp; 202 struct hci_link *sco; 203 int err; 204 205 sco = pcb->sp_link; 206 if (sco == NULL) 207 return EINVAL; 208 209 cp.con_handle = htole16(sco->hl_handle); 210 cp.reason = 0x13; /* "Remote User Terminated Connection" */ 211 212 err = hci_send_cmd(sco->hl_unit, HCI_CMD_DISCONNECT, &cp, sizeof(cp)); 213 if (err || linger == 0) { 214 sco->hl_sco = NULL; 215 pcb->sp_link = NULL; 216 hci_link_free(sco, err); 217 } 218 219 return err; 220 } 221 222 /* 223 * sco_detach(handle) 224 * 225 * Detach SCO pcb from handle and clear up 226 */ 227 int 228 sco_detach(struct sco_pcb **handle) 229 { 230 struct sco_pcb *pcb; 231 232 KKASSERT(handle != NULL); 233 pcb = *handle; 234 *handle = NULL; 235 236 if (pcb == NULL) 237 return EINVAL; 238 239 if (pcb->sp_link != NULL) { 240 sco_disconnect(pcb, 0); 241 pcb->sp_link = NULL; 242 } 243 244 LIST_REMOVE(pcb, sp_next); 245 kfree(pcb, M_BLUETOOTH); 246 return 0; 247 } 248 249 /* 250 * sco_listen(pcb) 251 * 252 * Mark pcb as a listener. 253 */ 254 int 255 sco_listen(struct sco_pcb *pcb) 256 { 257 258 if (pcb->sp_link != NULL) 259 return EINVAL; 260 261 pcb->sp_flags |= SP_LISTENING; 262 return 0; 263 } 264 265 /* 266 * sco_send(pcb, mbuf) 267 * 268 * Send data on SCO pcb. 269 * 270 * Gross hackage, we just output the packet directly onto the unit queue. 271 * This will work fine for one channel per unit, but for more channels it 272 * really needs fixing. We set the context so that when the packet is sent, 273 * we can drop a record from the socket buffer. 274 */ 275 int 276 sco_send(struct sco_pcb *pcb, struct mbuf *m) 277 { 278 hci_scodata_hdr_t *hdr; 279 int plen; 280 281 if (pcb->sp_link == NULL) { 282 m_freem(m); 283 return EINVAL; 284 } 285 286 plen = m->m_pkthdr.len; 287 DPRINTFN(10, "%d bytes\n", plen); 288 289 /* 290 * This is a temporary limitation, as USB devices cannot 291 * handle SCO packet sizes that are not an integer number 292 * of Isochronous frames. See ubt(4) 293 */ 294 if (plen != pcb->sp_mtu) { 295 m_freem(m); 296 return EMSGSIZE; 297 } 298 299 M_PREPEND(m, sizeof(hci_scodata_hdr_t), M_NOWAIT); 300 if (m == NULL) 301 return ENOMEM; 302 303 hdr = mtod(m, hci_scodata_hdr_t *); 304 hdr->type = HCI_SCO_DATA_PKT; 305 hdr->con_handle = htole16(pcb->sp_link->hl_handle); 306 hdr->length = plen; 307 308 pcb->sp_pending++; 309 M_SETCTX(m, pcb->sp_link); 310 hci_output_sco(pcb->sp_link->hl_unit, m); 311 312 return 0; 313 } 314 315 /* 316 * sco_setopt(pcb, option, addr) 317 * 318 * Set SCO pcb options 319 */ 320 int 321 sco_setopt(struct sco_pcb *pcb, int opt, void *addr) 322 { 323 int err = 0; 324 325 switch (opt) { 326 default: 327 err = ENOPROTOOPT; 328 break; 329 } 330 331 return err; 332 } 333 334 /* 335 * sco_getopt(pcb, option, addr) 336 * 337 * Get SCO pcb options 338 */ 339 int 340 sco_getopt(struct sco_pcb *pcb, int opt, void *addr) 341 { 342 343 switch (opt) { 344 case SO_SCO_MTU: 345 *(uint16_t *)addr = pcb->sp_mtu; 346 return sizeof(uint16_t); 347 348 case SO_SCO_HANDLE: 349 if (pcb->sp_link) { 350 *(uint16_t *)addr = pcb->sp_link->hl_handle; 351 return sizeof(uint16_t); 352 } 353 break; 354 355 default: 356 break; 357 } 358 return 0; 359 } 360