1 /* $NetBSD: btuart.c,v 1.32 2024/07/05 04:31:50 rin Exp $ */ 2 3 /*- 4 * Copyright (c) 2006, 2007 KIYOHARA Takashi 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 18 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 19 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, 20 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 21 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 22 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 24 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 25 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 26 * POSSIBILITY OF SUCH DAMAGE. 27 */ 28 29 #include <sys/cdefs.h> 30 __KERNEL_RCSID(0, "$NetBSD: btuart.c,v 1.32 2024/07/05 04:31:50 rin Exp $"); 31 32 #include <sys/param.h> 33 #include <sys/conf.h> 34 #include <sys/device.h> 35 #include <sys/errno.h> 36 #include <sys/fcntl.h> 37 #include <sys/kauth.h> 38 #include <sys/kernel.h> 39 #include <sys/malloc.h> 40 #include <sys/mbuf.h> 41 #include <sys/proc.h> 42 #include <sys/syslimits.h> 43 #include <sys/systm.h> 44 #include <sys/tty.h> 45 46 #include <sys/bus.h> 47 #include <sys/intr.h> 48 49 #include <netbt/bluetooth.h> 50 #include <netbt/hci.h> 51 52 #include "ioconf.h" 53 54 struct btuart_softc { 55 device_t sc_dev; 56 struct tty * sc_tp; /* tty pointer */ 57 58 bool sc_enabled; /* device is enabled */ 59 struct hci_unit *sc_unit; /* Bluetooth HCI handle */ 60 struct bt_stats sc_stats; 61 62 int sc_state; /* receive state */ 63 int sc_want; /* how much we want */ 64 struct mbuf * sc_rxp; /* incoming packet */ 65 66 bool sc_xmit; /* transmit is active */ 67 struct mbuf * sc_txp; /* outgoing packet */ 68 69 /* transmit queues */ 70 MBUFQ_HEAD() sc_cmdq; 71 MBUFQ_HEAD() sc_aclq; 72 MBUFQ_HEAD() sc_scoq; 73 }; 74 75 /* sc_state */ 76 #define BTUART_RECV_PKT_TYPE 0 /* packet type */ 77 #define BTUART_RECV_ACL_HDR 1 /* acl header */ 78 #define BTUART_RECV_SCO_HDR 2 /* sco header */ 79 #define BTUART_RECV_EVENT_HDR 3 /* event header */ 80 #define BTUART_RECV_ACL_DATA 4 /* acl packet data */ 81 #define BTUART_RECV_SCO_DATA 5 /* sco packet data */ 82 #define BTUART_RECV_EVENT_DATA 6 /* event packet data */ 83 84 static int btuart_match(device_t, cfdata_t, void *); 85 static void btuart_attach(device_t, device_t, void *); 86 static int btuart_detach(device_t, int); 87 88 static int btuartopen(dev_t, struct tty *); 89 static int btuartclose(struct tty *, int); 90 static int btuartioctl(struct tty *, u_long, void *, int, struct lwp *); 91 static int btuartinput(int, struct tty *); 92 static int btuartstart(struct tty *); 93 94 static int btuart_enable(device_t); 95 static void btuart_disable(device_t); 96 static void btuart_output_cmd(device_t, struct mbuf *); 97 static void btuart_output_acl(device_t, struct mbuf *); 98 static void btuart_output_sco(device_t, struct mbuf *); 99 static void btuart_stats(device_t, struct bt_stats *, int); 100 101 /* 102 * It doesn't need to be exported, as only btuartattach() uses it, 103 * but there's no "official" way to make it static. 104 */ 105 CFATTACH_DECL_NEW(btuart, sizeof(struct btuart_softc), 106 btuart_match, btuart_attach, btuart_detach, NULL); 107 108 static struct linesw btuart_disc = { 109 .l_name = "btuart", 110 .l_open = btuartopen, 111 .l_close = btuartclose, 112 .l_read = ttyerrio, 113 .l_write = ttyerrio, 114 .l_ioctl = btuartioctl, 115 .l_rint = btuartinput, 116 .l_start = btuartstart, 117 .l_modem = ttymodem, 118 .l_poll = ttyerrpoll, 119 }; 120 121 static const struct hci_if btuart_hci = { 122 .enable = btuart_enable, 123 .disable = btuart_disable, 124 .output_cmd = btuart_output_cmd, 125 .output_acl = btuart_output_acl, 126 .output_sco = btuart_output_sco, 127 .get_stats = btuart_stats, 128 .ipl = IPL_TTY, 129 }; 130 131 /***************************************************************************** 132 * 133 * autoconf(9) functions 134 */ 135 136 /* 137 * pseudo-device attach routine. 138 */ 139 void 140 btuartattach(int num __unused) 141 { 142 int error; 143 144 error = ttyldisc_attach(&btuart_disc); 145 if (error) { 146 aprint_error("%s: unable to register line discipline, " 147 "error = %d\n", btuart_cd.cd_name, error); 148 149 return; 150 } 151 152 error = config_cfattach_attach(btuart_cd.cd_name, &btuart_ca); 153 if (error) { 154 aprint_error("%s: unable to register cfattach, error = %d\n", 155 btuart_cd.cd_name, error); 156 157 config_cfdriver_detach(&btuart_cd); 158 (void) ttyldisc_detach(&btuart_disc); 159 } 160 } 161 162 /* 163 * Autoconf match routine. 164 */ 165 static int 166 btuart_match(device_t self __unused, cfdata_t cfdata __unused, 167 void *arg __unused) 168 { 169 170 /* pseudo-device; always present */ 171 return 1; 172 } 173 174 /* 175 * Autoconf attach routine. 176 * Called by config_attach_pseudo(9) when we open the line discipline. 177 */ 178 static void 179 btuart_attach(device_t parent __unused, device_t self, void *aux __unused) 180 { 181 struct btuart_softc *sc = device_private(self); 182 183 sc->sc_dev = self; 184 185 MBUFQ_INIT(&sc->sc_cmdq); 186 MBUFQ_INIT(&sc->sc_aclq); 187 MBUFQ_INIT(&sc->sc_scoq); 188 189 /* Attach Bluetooth unit */ 190 sc->sc_unit = hci_attach_pcb(&btuart_hci, self, 0); 191 if (sc->sc_unit == NULL) 192 aprint_error_dev(self, "HCI attach failed\n"); 193 } 194 195 /* 196 * Autoconf detach routine. 197 * Called when we close the line discipline. 198 */ 199 static int 200 btuart_detach(device_t self, int flags __unused) 201 { 202 struct btuart_softc *sc = device_private(self); 203 204 btuart_disable(self); 205 206 if (sc->sc_unit) { 207 hci_detach_pcb(sc->sc_unit); 208 sc->sc_unit = NULL; 209 } 210 211 return 0; 212 } 213 214 /***************************************************************************** 215 * 216 * Line discipline functions. 217 */ 218 219 static int 220 btuartopen(dev_t devno __unused, struct tty *tp) 221 { 222 struct btuart_softc *sc; 223 device_t dev; 224 cfdata_t cfdata; 225 struct lwp *l = curlwp; /* XXX */ 226 int error, unit, s; 227 228 error = kauth_authorize_device(l->l_cred, KAUTH_DEVICE_BLUETOOTH_BTUART, 229 KAUTH_ARG(KAUTH_REQ_DEVICE_BLUETOOTH_BTUART_ADD), NULL, NULL, NULL); 230 if (error) 231 return (error); 232 233 s = spltty(); 234 235 if (tp->t_linesw == &btuart_disc) { 236 sc = tp->t_sc; 237 if (sc != NULL) { 238 splx(s); 239 return EBUSY; 240 } 241 } 242 243 cfdata = malloc(sizeof(struct cfdata), M_DEVBUF, M_WAITOK); 244 for (unit = 0; unit < btuart_cd.cd_ndevs; unit++) 245 if (device_lookup(&btuart_cd, unit) == NULL) 246 break; 247 248 cfdata->cf_name = btuart_cd.cd_name; 249 cfdata->cf_atname = btuart_cd.cd_name; 250 cfdata->cf_unit = unit; 251 cfdata->cf_fstate = FSTATE_STAR; 252 253 dev = config_attach_pseudo(cfdata); 254 if (dev == NULL) { 255 free(cfdata, M_DEVBUF); 256 splx(s); 257 return EIO; 258 } 259 sc = device_private(dev); 260 261 aprint_normal_dev(dev, "major %llu minor %llu\n", 262 (unsigned long long)major(tp->t_dev), 263 (unsigned long long)minor(tp->t_dev)); 264 265 sc->sc_tp = tp; 266 tp->t_sc = sc; 267 268 ttylock(tp); 269 ttyflush(tp, FREAD | FWRITE); 270 ttyunlock(tp); 271 272 splx(s); 273 274 return 0; 275 } 276 277 static int 278 btuartclose(struct tty *tp, int flag __unused) 279 { 280 struct btuart_softc *sc = tp->t_sc; 281 cfdata_t cfdata; 282 int s; 283 284 s = spltty(); 285 286 ttylock(tp); 287 ttyflush(tp, FREAD | FWRITE); 288 ttyunlock(tp); /* XXX */ 289 290 ttyldisc_release(tp->t_linesw); 291 tp->t_linesw = ttyldisc_default(); 292 293 if (sc != NULL) { 294 tp->t_sc = NULL; 295 if (sc->sc_tp == tp) { 296 cfdata = device_cfdata(sc->sc_dev); 297 config_detach(sc->sc_dev, 0); 298 free(cfdata, M_DEVBUF); 299 } 300 } 301 302 splx(s); 303 304 return 0; 305 } 306 307 static int 308 btuartioctl(struct tty *tp, u_long cmd, void *data __unused, 309 int flag __unused, struct lwp *l __unused) 310 { 311 struct btuart_softc *sc = tp->t_sc; 312 int error; 313 314 /* 315 * XXX 316 * This function can be called without KERNEL_LOCK when caller's 317 * struct cdevsw is set D_MPSAFE. Is KERNEL_LOCK required? 318 */ 319 320 if (sc == NULL || tp != sc->sc_tp) 321 return EPASSTHROUGH; 322 323 switch(cmd) { 324 default: 325 error = EPASSTHROUGH; 326 break; 327 } 328 329 return error; 330 } 331 332 static int 333 btuartinput(int c, struct tty *tp) 334 { 335 struct btuart_softc *sc = tp->t_sc; 336 struct mbuf *m = sc->sc_rxp; 337 int space = 0; 338 339 if (!sc->sc_enabled) 340 return 0; 341 342 c &= TTY_CHARMASK; 343 344 /* If we already started a packet, find the trailing end of it. */ 345 if (m) { 346 while (m->m_next) 347 m = m->m_next; 348 349 space = M_TRAILINGSPACE(m); 350 } 351 352 if (space == 0) { 353 if (m == NULL) { 354 /* new packet */ 355 MGETHDR(m, M_DONTWAIT, MT_DATA); 356 if (m == NULL) { 357 aprint_error_dev(sc->sc_dev, "out of memory\n"); 358 sc->sc_stats.err_rx++; 359 return 0; /* (lost sync) */ 360 } 361 362 sc->sc_rxp = m; 363 m->m_pkthdr.len = m->m_len = 0; 364 space = MHLEN; 365 366 sc->sc_state = BTUART_RECV_PKT_TYPE; 367 sc->sc_want = 1; 368 } else { 369 /* extend mbuf */ 370 MGET(m->m_next, M_DONTWAIT, MT_DATA); 371 if (m->m_next == NULL) { 372 aprint_error_dev(sc->sc_dev, "out of memory\n"); 373 sc->sc_stats.err_rx++; 374 return 0; /* (lost sync) */ 375 } 376 377 m = m->m_next; 378 m->m_len = 0; 379 space = MLEN; 380 381 if (sc->sc_want > MINCLSIZE) { 382 MCLGET(m, M_DONTWAIT); 383 if (m->m_flags & M_EXT) 384 space = MCLBYTES; 385 } 386 } 387 } 388 389 mtod(m, uint8_t *)[m->m_len++] = c; 390 sc->sc_rxp->m_pkthdr.len++; 391 sc->sc_stats.byte_rx++; 392 393 sc->sc_want--; 394 if (sc->sc_want > 0) 395 return 0; /* want more */ 396 397 switch (sc->sc_state) { 398 case BTUART_RECV_PKT_TYPE: /* Got packet type */ 399 400 switch (c) { 401 case HCI_ACL_DATA_PKT: 402 sc->sc_state = BTUART_RECV_ACL_HDR; 403 sc->sc_want = sizeof(hci_acldata_hdr_t) - 1; 404 break; 405 406 case HCI_SCO_DATA_PKT: 407 sc->sc_state = BTUART_RECV_SCO_HDR; 408 sc->sc_want = sizeof(hci_scodata_hdr_t) - 1; 409 break; 410 411 case HCI_EVENT_PKT: 412 sc->sc_state = BTUART_RECV_EVENT_HDR; 413 sc->sc_want = sizeof(hci_event_hdr_t) - 1; 414 break; 415 416 default: 417 aprint_error_dev(sc->sc_dev, 418 "Unknown packet type=%#x!\n", c); 419 sc->sc_stats.err_rx++; 420 m_freem(sc->sc_rxp); 421 sc->sc_rxp = NULL; 422 return 0; /* (lost sync) */ 423 } 424 425 break; 426 427 /* 428 * we assume (correctly of course :) that the packet headers all fit 429 * into a single pkthdr mbuf 430 */ 431 case BTUART_RECV_ACL_HDR: /* Got ACL Header */ 432 sc->sc_state = BTUART_RECV_ACL_DATA; 433 sc->sc_want = mtod(m, hci_acldata_hdr_t *)->length; 434 sc->sc_want = le16toh(sc->sc_want); 435 break; 436 437 case BTUART_RECV_SCO_HDR: /* Got SCO Header */ 438 sc->sc_state = BTUART_RECV_SCO_DATA; 439 sc->sc_want = mtod(m, hci_scodata_hdr_t *)->length; 440 break; 441 442 case BTUART_RECV_EVENT_HDR: /* Got Event Header */ 443 sc->sc_state = BTUART_RECV_EVENT_DATA; 444 sc->sc_want = mtod(m, hci_event_hdr_t *)->length; 445 break; 446 447 case BTUART_RECV_ACL_DATA: /* ACL Packet Complete */ 448 if (!hci_input_acl(sc->sc_unit, sc->sc_rxp)) 449 sc->sc_stats.err_rx++; 450 451 sc->sc_stats.acl_rx++; 452 sc->sc_rxp = m = NULL; 453 break; 454 455 case BTUART_RECV_SCO_DATA: /* SCO Packet Complete */ 456 if (!hci_input_sco(sc->sc_unit, sc->sc_rxp)) 457 sc->sc_stats.err_rx++; 458 459 sc->sc_stats.sco_rx++; 460 sc->sc_rxp = m = NULL; 461 break; 462 463 case BTUART_RECV_EVENT_DATA: /* Event Packet Complete */ 464 if (!hci_input_event(sc->sc_unit, sc->sc_rxp)) 465 sc->sc_stats.err_rx++; 466 467 sc->sc_stats.evt_rx++; 468 sc->sc_rxp = m = NULL; 469 break; 470 471 default: 472 panic("%s: invalid state %d!\n", 473 device_xname(sc->sc_dev), sc->sc_state); 474 } 475 476 return 0; 477 } 478 479 static int 480 btuartstart(struct tty *tp) 481 { 482 struct btuart_softc *sc = tp->t_sc; 483 struct mbuf *m; 484 int count, rlen; 485 uint8_t *rptr; 486 487 if (!sc->sc_enabled) 488 return 0; 489 490 m = sc->sc_txp; 491 if (m == NULL) { 492 if (MBUFQ_FIRST(&sc->sc_cmdq)) { 493 MBUFQ_DEQUEUE(&sc->sc_cmdq, m); 494 sc->sc_stats.cmd_tx++; 495 } else if (MBUFQ_FIRST(&sc->sc_scoq)) { 496 MBUFQ_DEQUEUE(&sc->sc_scoq, m); 497 sc->sc_stats.sco_tx++; 498 } else if (MBUFQ_FIRST(&sc->sc_aclq)) { 499 MBUFQ_DEQUEUE(&sc->sc_aclq, m); 500 sc->sc_stats.acl_tx++; 501 } else { 502 sc->sc_xmit = false; 503 return 0; /* no more to send */ 504 } 505 506 sc->sc_txp = m; 507 sc->sc_xmit = true; 508 } 509 510 count = 0; 511 rlen = 0; 512 rptr = mtod(m, uint8_t *); 513 514 for(;;) { 515 if (rlen >= m->m_len) { 516 m = m->m_next; 517 if (m == NULL) { 518 m = sc->sc_txp; 519 sc->sc_txp = NULL; 520 521 if (M_GETCTX(m, void *) == NULL) 522 m_freem(m); 523 else if (!hci_complete_sco(sc->sc_unit, m)) 524 sc->sc_stats.err_tx++; 525 526 break; 527 } 528 529 rlen = 0; 530 rptr = mtod(m, uint8_t *); 531 continue; 532 } 533 534 if (putc(*rptr++, &tp->t_outq) < 0) { 535 m_adj(m, rlen); 536 break; 537 } 538 rlen++; 539 count++; 540 } 541 542 sc->sc_stats.byte_tx += count; 543 544 if (tp->t_outq.c_cc != 0 && tp->t_oproc != NULL) 545 (*tp->t_oproc)(tp); 546 547 return 0; 548 } 549 550 /***************************************************************************** 551 * 552 * bluetooth(9) functions 553 */ 554 555 static int 556 btuart_enable(device_t self) 557 { 558 struct btuart_softc *sc = device_private(self); 559 int s; 560 561 if (sc->sc_enabled) 562 return 0; 563 564 s = spltty(); 565 566 sc->sc_enabled = true; 567 sc->sc_xmit = false; 568 569 splx(s); 570 571 return 0; 572 } 573 574 static void 575 btuart_disable(device_t self) 576 { 577 struct btuart_softc *sc = device_private(self); 578 int s; 579 580 if (!sc->sc_enabled) 581 return; 582 583 s = spltty(); 584 585 m_freem(sc->sc_rxp); 586 sc->sc_rxp = NULL; 587 588 m_freem(sc->sc_txp); 589 sc->sc_txp = NULL; 590 591 MBUFQ_DRAIN(&sc->sc_cmdq); 592 MBUFQ_DRAIN(&sc->sc_aclq); 593 MBUFQ_DRAIN(&sc->sc_scoq); 594 595 sc->sc_enabled = false; 596 597 splx(s); 598 } 599 600 static void 601 btuart_output_cmd(device_t self, struct mbuf *m) 602 { 603 struct btuart_softc *sc = device_private(self); 604 int s; 605 606 KASSERT(sc->sc_enabled); 607 608 M_SETCTX(m, NULL); 609 610 s = spltty(); 611 MBUFQ_ENQUEUE(&sc->sc_cmdq, m); 612 if (!sc->sc_xmit) 613 btuartstart(sc->sc_tp); 614 615 splx(s); 616 } 617 618 static void 619 btuart_output_acl(device_t self, struct mbuf *m) 620 { 621 struct btuart_softc *sc = device_private(self); 622 int s; 623 624 KASSERT(sc->sc_enabled); 625 626 M_SETCTX(m, NULL); 627 628 s = spltty(); 629 MBUFQ_ENQUEUE(&sc->sc_aclq, m); 630 if (!sc->sc_xmit) 631 btuartstart(sc->sc_tp); 632 633 splx(s); 634 } 635 636 static void 637 btuart_output_sco(device_t self, struct mbuf *m) 638 { 639 struct btuart_softc *sc = device_private(self); 640 int s; 641 642 KASSERT(sc->sc_enabled); 643 644 s = spltty(); 645 MBUFQ_ENQUEUE(&sc->sc_scoq, m); 646 if (!sc->sc_xmit) 647 btuartstart(sc->sc_tp); 648 649 splx(s); 650 } 651 652 static void 653 btuart_stats(device_t self, struct bt_stats *dest, int flush) 654 { 655 struct btuart_softc *sc = device_private(self); 656 int s; 657 658 s = spltty(); 659 660 memcpy(dest, &sc->sc_stats, sizeof(struct bt_stats)); 661 662 if (flush) 663 memset(&sc->sc_stats, 0, sizeof(struct bt_stats)); 664 665 splx(s); 666 } 667
Indexes created Sun Sep 21 16:09:51 GMT 2025