1 /*- 2 * (MPSAFE) 3 * 4 * Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> 5 * All rights reserved. 6 * 7 * ng_h4.c 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_h4.c,v 1.10 2005/10/31 17:57:43 max Exp $ 31 * $FreeBSD: head/sys/netgraph/bluetooth/drivers/h4/ng_h4.c 243882 2012-12-05 08:04:20Z glebius $ 32 * 33 * Based on: 34 * --------- 35 * 36 * FreeBSD: src/sys/netgraph/ng_tty.c 37 * Author: Archie Cobbs <archie@freebsd.org> 38 * 39 */ 40 41 #include <sys/param.h> 42 #include <sys/systm.h> 43 #include <sys/kernel.h> 44 #include <sys/conf.h> 45 #include <sys/endian.h> 46 #include <sys/errno.h> 47 #include <sys/fcntl.h> 48 #include <sys/malloc.h> 49 #include <sys/mbuf.h> 50 #include <sys/priv.h> 51 #include <sys/socket.h> 52 #include <sys/tty.h> 53 #include <sys/ttycom.h> 54 #include <net/if.h> 55 #include <net/if_var.h> 56 #include <netgraph7/ng_message.h> 57 #include <netgraph7/netgraph.h> 58 #include <netgraph7/ng_parse.h> 59 #include <netgraph7/bluetooth/include/ng_bluetooth.h> 60 #include <netgraph7/bluetooth/include/ng_hci.h> 61 #include <netgraph7/bluetooth/include/ng_h4.h> 62 #include <netgraph7/bluetooth/drivers/h4/ng_h4_var.h> 63 #include <netgraph7/bluetooth/drivers/h4/ng_h4_prse.h> 64 65 /***************************************************************************** 66 ***************************************************************************** 67 ** This node implements a Bluetooth HCI UART transport layer as per chapter 68 ** H4 of the Bluetooth Specification Book v1.1. It is a terminal line 69 ** discipline that is also a netgraph node. Installing this line discipline 70 ** on a terminal device instantiates a new netgraph node of this type, which 71 ** allows access to the device via the "hook" hook of the node. 72 ** 73 ** Once the line discipline is installed, you can find out the name of the 74 ** corresponding netgraph node via a NGIOCGINFO ioctl(). 75 ***************************************************************************** 76 *****************************************************************************/ 77 78 /* MALLOC define */ 79 #ifndef NG_SEPARATE_MALLOC 80 MALLOC_DEFINE(M_NETGRAPH_H4, "netgraph_h4", "Netgraph Bluetooth H4 node"); 81 #else 82 #define M_NETGRAPH_H4 M_NETGRAPH 83 #endif /* NG_SEPARATE_MALLOC */ 84 85 /* Line discipline methods */ 86 static int ng_h4_open (struct cdev *, struct tty *); 87 static int ng_h4_close (struct tty *, int); 88 static int ng_h4_read (struct tty *, struct uio *, int); 89 static int ng_h4_write (struct tty *, struct uio *, int); 90 static int ng_h4_input (int, struct tty *); 91 static int ng_h4_start (struct tty *); 92 static int ng_h4_ioctl (struct tty *, u_long, caddr_t, 93 int, struct ucred *); 94 95 /* Line discipline descriptor */ 96 static struct linesw ng_h4_disc = { 97 ng_h4_open, /* open */ 98 ng_h4_close, /* close */ 99 ng_h4_read, /* read */ 100 ng_h4_write, /* write */ 101 ng_h4_ioctl, /* ioctl */ 102 ng_h4_input, /* input */ 103 ng_h4_start, /* start */ 104 ttymodem /* modem */ 105 }; 106 107 /* Netgraph methods */ 108 static ng_constructor_t ng_h4_constructor; 109 static ng_rcvmsg_t ng_h4_rcvmsg; 110 static ng_shutdown_t ng_h4_shutdown; 111 static ng_newhook_t ng_h4_newhook; 112 static ng_connect_t ng_h4_connect; 113 static ng_rcvdata_t ng_h4_rcvdata; 114 static ng_disconnect_t ng_h4_disconnect; 115 116 /* Other stuff */ 117 static void ng_h4_process_timeout (node_p, hook_p, void *, int); 118 static int ng_h4_mod_event (module_t, int, void *); 119 120 /* Netgraph node type descriptor */ 121 static struct ng_type typestruct = { 122 .version = NG_ABI_VERSION, 123 .name = NG_H4_NODE_TYPE, 124 .mod_event = ng_h4_mod_event, 125 .constructor = ng_h4_constructor, 126 .rcvmsg = ng_h4_rcvmsg, 127 .shutdown = ng_h4_shutdown, 128 .newhook = ng_h4_newhook, 129 .connect = ng_h4_connect, 130 .rcvdata = ng_h4_rcvdata, 131 .disconnect = ng_h4_disconnect, 132 .cmdlist = ng_h4_cmdlist 133 }; 134 NETGRAPH_INIT(h4, &typestruct); 135 MODULE_VERSION(ng_h4, NG_BLUETOOTH_VERSION); 136 137 static int ng_h4_node = 0; 138 139 /***************************************************************************** 140 ***************************************************************************** 141 ** Line discipline methods 142 ***************************************************************************** 143 *****************************************************************************/ 144 145 /* 146 * Set our line discipline on the tty. 147 */ 148 149 static int 150 ng_h4_open(struct cdev *dev, struct tty *tp) 151 { 152 struct thread *td = curthread; 153 char name[NG_NODESIZ]; 154 ng_h4_info_p sc = NULL; 155 int error; 156 157 /* Super-user only */ 158 error = priv_check(td, PRIV_NETGRAPH_TTY); /* XXX */ 159 if (error != 0) 160 return (error); 161 162 /* Initialize private struct */ 163 sc = kmalloc(sizeof(*sc), M_NETGRAPH_H4, M_WAITOK | M_NULLOK | M_ZERO); 164 if (sc == NULL) 165 return (ENOMEM); 166 167 lwkt_gettoken(&tp->t_token); 168 sc->tp = tp; 169 sc->debug = NG_H4_WARN_LEVEL; 170 171 sc->state = NG_H4_W4_PKT_IND; 172 sc->want = 1; 173 sc->got = 0; 174 175 sc->outq.ifq_maxlen = NG_H4_DEFAULTQLEN; 176 ng_callout_init(&sc->timo); 177 178 NG_H4_LOCK(sc); 179 180 /* Setup netgraph node */ 181 error = ng_make_node_common(&typestruct, &sc->node); 182 if (error != 0) { 183 NG_H4_UNLOCK(sc); 184 185 kprintf("%s: Unable to create new node!\n", __func__); 186 187 bzero(sc, sizeof(*sc)); 188 kfree(sc, M_NETGRAPH_H4); 189 190 lwkt_reltoken(&tp->t_token); 191 return (error); 192 } 193 194 /* Assign node its name */ 195 ksnprintf(name, sizeof(name), "%s%d", typestruct.name, ng_h4_node ++); 196 197 error = ng_name_node(sc->node, name); 198 if (error != 0) { 199 NG_H4_UNLOCK(sc); 200 201 kprintf("%s: %s - node name exists?\n", __func__, name); 202 203 NG_NODE_UNREF(sc->node); 204 bzero(sc, sizeof(*sc)); 205 kfree(sc, M_NETGRAPH_H4); 206 207 lwkt_reltoken(&tp->t_token); 208 return (error); 209 } 210 211 /* Set back pointers */ 212 NG_NODE_SET_PRIVATE(sc->node, sc); 213 tp->t_sc = (caddr_t) sc; 214 215 /* The node has to be a WRITER because data can change node status */ 216 NG_NODE_FORCE_WRITER(sc->node); 217 218 /* 219 * Pre-allocate cblocks to the an appropriate amount. 220 * I'm not sure what is appropriate. 221 */ 222 223 ttyflush(tp, FREAD | FWRITE); 224 clist_alloc_cblocks(&tp->t_canq, 0, 0); 225 clist_alloc_cblocks(&tp->t_rawq, 0, 0); 226 clist_alloc_cblocks(&tp->t_outq, 227 MLEN + NG_H4_HIWATER, MLEN + NG_H4_HIWATER); 228 229 NG_H4_UNLOCK(sc); 230 231 lwkt_reltoken(&tp->t_token); 232 return (error); 233 } /* ng_h4_open */ 234 235 /* 236 * Line specific close routine, called from device close routine 237 * and from ttioctl. This causes the node to be destroyed as well. 238 */ 239 240 static int 241 ng_h4_close(struct tty *tp, int flag) 242 { 243 ng_h4_info_p sc = (ng_h4_info_p) tp->t_sc; 244 245 lwkt_gettoken(&tp->t_token); 246 ttyflush(tp, FREAD | FWRITE); 247 clist_free_cblocks(&tp->t_outq); 248 249 if (sc != NULL) { 250 NG_H4_LOCK(sc); 251 252 if (callout_pending(&sc->timo)) 253 ng_uncallout(&sc->timo, sc->node); 254 255 tp->t_sc = NULL; 256 sc->dying = 1; 257 258 NG_H4_UNLOCK(sc); 259 260 ng_rmnode_self(sc->node); 261 } 262 263 lwkt_reltoken(&tp->t_token); 264 return (0); 265 } /* ng_h4_close */ 266 267 /* 268 * Once the device has been turned into a node, we don't allow reading. 269 */ 270 271 static int 272 ng_h4_read(struct tty *tp, struct uio *uio, int flag) 273 { 274 return (EIO); 275 } /* ng_h4_read */ 276 277 /* 278 * Once the device has been turned into a node, we don't allow writing. 279 */ 280 281 static int 282 ng_h4_write(struct tty *tp, struct uio *uio, int flag) 283 { 284 return (EIO); 285 } /* ng_h4_write */ 286 287 /* 288 * We implement the NGIOCGINFO ioctl() defined in ng_message.h. 289 */ 290 291 static int 292 ng_h4_ioctl(struct tty *tp, u_long cmd, caddr_t data, int flag, 293 struct ucred *cred) 294 { 295 ng_h4_info_p sc = (ng_h4_info_p) tp->t_sc; 296 int error = 0; 297 298 if (sc == NULL) 299 return (ENXIO); 300 301 lwkt_gettoken(&tp->t_token); 302 NG_H4_LOCK(sc); 303 304 switch (cmd) { 305 case NGIOCGINFO: 306 #undef NI 307 #define NI(x) ((struct nodeinfo *)(x)) 308 309 bzero(data, sizeof(*NI(data))); 310 311 if (NG_NODE_HAS_NAME(sc->node)) 312 strncpy(NI(data)->name, NG_NODE_NAME(sc->node), 313 sizeof(NI(data)->name) - 1); 314 315 strncpy(NI(data)->type, sc->node->nd_type->name, 316 sizeof(NI(data)->type) - 1); 317 318 NI(data)->id = (u_int32_t) ng_node2ID(sc->node); 319 NI(data)->hooks = NG_NODE_NUMHOOKS(sc->node); 320 break; 321 322 default: 323 error = ENOIOCTL; 324 break; 325 } 326 327 NG_H4_UNLOCK(sc); 328 329 lwkt_reltoken(&tp->t_token); 330 return (error); 331 } /* ng_h4_ioctl */ 332 333 /* 334 * Receive data coming from the device. We get one character at a time, which 335 * is kindof silly. 336 */ 337 338 static int 339 ng_h4_input(int c, struct tty *tp) 340 { 341 ng_h4_info_p sc = (ng_h4_info_p) tp->t_sc; 342 343 lwkt_gettoken(&tp->t_token); 344 if (sc == NULL || tp != sc->tp || 345 sc->node == NULL || NG_NODE_NOT_VALID(sc->node)) { 346 lwkt_reltoken(&tp->t_token); 347 return (0); 348 } 349 350 NG_H4_LOCK(sc); 351 352 /* Check for error conditions */ 353 if ((tp->t_state & TS_CONNECTED) == 0) { 354 NG_H4_INFO("%s: %s - no carrier\n", __func__, 355 NG_NODE_NAME(sc->node)); 356 357 sc->state = NG_H4_W4_PKT_IND; 358 sc->want = 1; 359 sc->got = 0; 360 361 NG_H4_UNLOCK(sc); 362 363 lwkt_reltoken(&tp->t_token); 364 return (0); /* XXX Loss of synchronization here! */ 365 } 366 367 /* Check for framing error or overrun on this char */ 368 if (c & TTY_ERRORMASK) { 369 NG_H4_ERR("%s: %s - line error %#x, c=%#x\n", __func__, 370 NG_NODE_NAME(sc->node), c & TTY_ERRORMASK, 371 c & TTY_CHARMASK); 372 373 NG_H4_STAT_IERROR(sc->stat); 374 375 sc->state = NG_H4_W4_PKT_IND; 376 sc->want = 1; 377 sc->got = 0; 378 379 NG_H4_UNLOCK(sc); 380 381 lwkt_reltoken(&tp->t_token); 382 return (0); /* XXX Loss of synchronization here! */ 383 } 384 385 NG_H4_STAT_BYTES_RECV(sc->stat, 1); 386 387 /* Append char to mbuf */ 388 if (sc->got >= sizeof(sc->ibuf)) { 389 NG_H4_ALERT("%s: %s - input buffer overflow, c=%#x, got=%d\n", 390 __func__, NG_NODE_NAME(sc->node), c & TTY_CHARMASK, 391 sc->got); 392 393 NG_H4_STAT_IERROR(sc->stat); 394 395 sc->state = NG_H4_W4_PKT_IND; 396 sc->want = 1; 397 sc->got = 0; 398 399 NG_H4_UNLOCK(sc); 400 401 lwkt_reltoken(&tp->t_token); 402 return (0); /* XXX Loss of synchronization here! */ 403 } 404 405 sc->ibuf[sc->got ++] = (c & TTY_CHARMASK); 406 407 NG_H4_INFO("%s: %s - got char %#x, want=%d, got=%d\n", __func__, 408 NG_NODE_NAME(sc->node), c, sc->want, sc->got); 409 410 if (sc->got < sc->want) { 411 NG_H4_UNLOCK(sc); 412 413 lwkt_reltoken(&tp->t_token); 414 return (0); /* Wait for more */ 415 } 416 417 switch (sc->state) { 418 /* Got packet indicator */ 419 case NG_H4_W4_PKT_IND: 420 NG_H4_INFO("%s: %s - got packet indicator %#x\n", __func__, 421 NG_NODE_NAME(sc->node), sc->ibuf[0]); 422 423 sc->state = NG_H4_W4_PKT_HDR; 424 425 /* 426 * Since packet indicator included in the packet header 427 * just set sc->want to sizeof(packet header). 428 */ 429 430 switch (sc->ibuf[0]) { 431 case NG_HCI_ACL_DATA_PKT: 432 sc->want = sizeof(ng_hci_acldata_pkt_t); 433 break; 434 435 case NG_HCI_SCO_DATA_PKT: 436 sc->want = sizeof(ng_hci_scodata_pkt_t); 437 break; 438 439 case NG_HCI_EVENT_PKT: 440 sc->want = sizeof(ng_hci_event_pkt_t); 441 break; 442 443 default: 444 NG_H4_WARN("%s: %s - ignoring unknown packet " \ 445 "type=%#x\n", __func__, NG_NODE_NAME(sc->node), 446 sc->ibuf[0]); 447 448 NG_H4_STAT_IERROR(sc->stat); 449 450 sc->state = NG_H4_W4_PKT_IND; 451 sc->want = 1; 452 sc->got = 0; 453 break; 454 } 455 break; 456 457 /* Got packet header */ 458 case NG_H4_W4_PKT_HDR: 459 sc->state = NG_H4_W4_PKT_DATA; 460 461 switch (sc->ibuf[0]) { 462 case NG_HCI_ACL_DATA_PKT: 463 c = le16toh(((ng_hci_acldata_pkt_t *) 464 (sc->ibuf))->length); 465 break; 466 467 case NG_HCI_SCO_DATA_PKT: 468 c = ((ng_hci_scodata_pkt_t *)(sc->ibuf))->length; 469 break; 470 471 case NG_HCI_EVENT_PKT: 472 c = ((ng_hci_event_pkt_t *)(sc->ibuf))->length; 473 break; 474 475 default: 476 KASSERT((0), ("Invalid packet type=%#x", 477 sc->ibuf[0])); 478 break; 479 } 480 481 NG_H4_INFO("%s: %s - got packet header, packet type=%#x, " \ 482 "packet size=%d, payload size=%d\n", __func__, 483 NG_NODE_NAME(sc->node), sc->ibuf[0], sc->got, c); 484 485 if (c > 0) { 486 sc->want += c; 487 488 /* 489 * Try to prevent possible buffer overrun 490 * 491 * XXX I'm *really* confused here. It turns out 492 * that Xircom card sends us packets with length 493 * greater then 512 bytes! This is greater then 494 * our old receive buffer (ibuf) size. In the same 495 * time the card demands from us *not* to send 496 * packets greater then 192 bytes. Weird! How the 497 * hell i should know how big *receive* buffer 498 * should be? For now increase receiving buffer 499 * size to 1K and add the following check. 500 */ 501 502 if (sc->want >= sizeof(sc->ibuf)) { 503 int b; 504 505 NG_H4_ALERT("%s: %s - packet too big for " \ 506 "buffer, type=%#x, got=%d, want=%d, " \ 507 "length=%d\n", __func__, 508 NG_NODE_NAME(sc->node), sc->ibuf[0], 509 sc->got, sc->want, c); 510 511 NG_H4_ALERT("Packet header:\n"); 512 for (b = 0; b < sc->got; b++) 513 NG_H4_ALERT("%#x ", sc->ibuf[b]); 514 NG_H4_ALERT("\n"); 515 516 /* Reset state */ 517 NG_H4_STAT_IERROR(sc->stat); 518 519 sc->state = NG_H4_W4_PKT_IND; 520 sc->want = 1; 521 sc->got = 0; 522 } 523 524 break; 525 } 526 527 /* else FALLTHROUGH and deliver frame */ 528 /* XXX Is this true? Should we deliver empty frame? */ 529 530 /* Got packet data */ 531 case NG_H4_W4_PKT_DATA: 532 NG_H4_INFO("%s: %s - got full packet, packet type=%#x, " \ 533 "packet size=%d\n", __func__, 534 NG_NODE_NAME(sc->node), sc->ibuf[0], sc->got); 535 536 if (sc->hook != NULL && NG_HOOK_IS_VALID(sc->hook)) { 537 struct mbuf *m = NULL; 538 539 MGETHDR(m, M_NOWAIT, MT_DATA); 540 if (m != NULL) { 541 m->m_pkthdr.len = 0; 542 543 /* XXX m_copyback() is stupid */ 544 m->m_len = min(MHLEN, sc->got); 545 546 m_copyback(m, 0, sc->got, sc->ibuf); 547 NG_SEND_DATA_ONLY(c, sc->hook, m); 548 } else { 549 NG_H4_ERR("%s: %s - could not get mbuf\n", 550 __func__, NG_NODE_NAME(sc->node)); 551 552 NG_H4_STAT_IERROR(sc->stat); 553 } 554 } 555 556 sc->state = NG_H4_W4_PKT_IND; 557 sc->want = 1; 558 sc->got = 0; 559 560 NG_H4_STAT_PCKTS_RECV(sc->stat); 561 break; 562 563 default: 564 KASSERT((0), ("Invalid H4 node state=%d", sc->state)); 565 break; 566 } 567 568 NG_H4_UNLOCK(sc); 569 570 lwkt_reltoken(&tp->t_token); 571 return (0); 572 } /* ng_h4_input */ 573 574 /* 575 * This is called when the device driver is ready for more output. Called from 576 * tty system. 577 */ 578 579 static int 580 ng_h4_start(struct tty *tp) 581 { 582 ng_h4_info_p sc = (ng_h4_info_p) tp->t_sc; 583 struct mbuf *m = NULL; 584 int size; 585 586 lwkt_gettoken(&tp->t_token); 587 if (sc == NULL || tp != sc->tp || 588 sc->node == NULL || NG_NODE_NOT_VALID(sc->node)) { 589 lwkt_reltoken(&tp->t_token); 590 return (0); 591 } 592 593 #if 0 594 while (tp->t_outq.c_cc < NG_H4_HIWATER) { /* XXX 2.2 specific ? */ 595 #else 596 while (1) { 597 #endif 598 /* Remove first mbuf from queue */ 599 IF_DEQUEUE(&sc->outq, m); 600 if (m == NULL) 601 break; 602 603 /* Send as much of it as possible */ 604 while (m != NULL) { 605 size = m->m_len - b_to_q(mtod(m, u_char *), 606 m->m_len, &tp->t_outq); 607 608 NG_H4_LOCK(sc); 609 NG_H4_STAT_BYTES_SENT(sc->stat, size); 610 NG_H4_UNLOCK(sc); 611 612 m->m_data += size; 613 m->m_len -= size; 614 if (m->m_len > 0) 615 break; /* device can't take no more */ 616 617 m = m_free(m); 618 } 619 620 /* Put remainder of mbuf chain (if any) back on queue */ 621 if (m != NULL) { 622 IF_PREPEND(&sc->outq, m); 623 break; 624 } 625 626 /* Full packet has been sent */ 627 NG_H4_LOCK(sc); 628 NG_H4_STAT_PCKTS_SENT(sc->stat); 629 NG_H4_UNLOCK(sc); 630 } 631 632 /* 633 * Call output process whether or not there is any output. We are 634 * being called in lieu of ttstart and must do what it would. 635 */ 636 637 if (tp->t_oproc != NULL) 638 (*tp->t_oproc) (tp); 639 640 /* 641 * This timeout is needed for operation on a pseudo-tty, because the 642 * pty code doesn't call pppstart after it has drained the t_outq. 643 */ 644 645 NG_H4_LOCK(sc); 646 647 if (!IF_QEMPTY(&sc->outq) && !callout_pending(&sc->timo)) 648 ng_callout(&sc->timo, sc->node, NULL, 1, 649 ng_h4_process_timeout, NULL, 0); 650 651 NG_H4_UNLOCK(sc); 652 653 lwkt_reltoken(&tp->t_token); 654 return (0); 655 } /* ng_h4_start */ 656 657 /***************************************************************************** 658 ***************************************************************************** 659 ** Netgraph node methods 660 ***************************************************************************** 661 *****************************************************************************/ 662 663 /* 664 * Initialize a new node of this type. We only allow nodes to be created as 665 * a result of setting the line discipline on a tty, so always return an error 666 * if not. 667 */ 668 669 static int 670 ng_h4_constructor(node_p node) 671 { 672 return (EOPNOTSUPP); 673 } /* ng_h4_constructor */ 674 675 /* 676 * Add a new hook. There can only be one. 677 */ 678 679 static int 680 ng_h4_newhook(node_p node, hook_p hook, const char *name) 681 { 682 ng_h4_info_p sc = (ng_h4_info_p) NG_NODE_PRIVATE(node); 683 684 if (strcmp(name, NG_H4_HOOK) != 0) 685 return (EINVAL); 686 687 NG_H4_LOCK(sc); 688 689 if (sc->hook != NULL) { 690 NG_H4_UNLOCK(sc); 691 return (EISCONN); 692 } 693 sc->hook = hook; 694 695 NG_H4_UNLOCK(sc); 696 697 return (0); 698 } /* ng_h4_newhook */ 699 700 /* 701 * Connect hook. Just say yes. 702 */ 703 704 static int 705 ng_h4_connect(hook_p hook) 706 { 707 ng_h4_info_p sc = (ng_h4_info_p) NG_NODE_PRIVATE(NG_HOOK_NODE(hook)); 708 709 if (hook != sc->hook) 710 panic("%s: hook != sc->hook", __func__); 711 712 NG_HOOK_FORCE_QUEUE(NG_HOOK_PEER(hook)); 713 NG_HOOK_FORCE_QUEUE(hook); 714 715 return (0); 716 } /* ng_h4_connect */ 717 718 /* 719 * Disconnect the hook 720 */ 721 722 static int 723 ng_h4_disconnect(hook_p hook) 724 { 725 ng_h4_info_p sc = (ng_h4_info_p) NG_NODE_PRIVATE(NG_HOOK_NODE(hook)); 726 727 /* 728 * We need to check for sc != NULL because we can be called from 729 * ng_h4_close() via ng_rmnode_self() 730 */ 731 732 if (sc != NULL) { 733 if (hook != sc->hook) 734 panic("%s: hook != sc->hook", __func__); 735 736 NG_H4_LOCK(sc); 737 738 /* XXX do we have to untimeout and drain out queue? */ 739 if (callout_pending(&sc->timo)) 740 ng_uncallout(&sc->timo, sc->node); 741 742 IF_DRAIN(&sc->outq); 743 744 sc->state = NG_H4_W4_PKT_IND; 745 sc->want = 1; 746 sc->got = 0; 747 748 sc->hook = NULL; 749 750 NG_H4_UNLOCK(sc); 751 } 752 753 return (0); 754 } /* ng_h4_disconnect */ 755 756 /* 757 * Remove this node. The does the netgraph portion of the shutdown. 758 * This should only be called indirectly from ng_h4_close(). 759 */ 760 761 static int 762 ng_h4_shutdown(node_p node) 763 { 764 ng_h4_info_p sc = (ng_h4_info_p) NG_NODE_PRIVATE(node); 765 766 NG_H4_LOCK(sc); 767 768 if (!sc->dying) { 769 NG_H4_UNLOCK(sc); 770 771 NG_NODE_REVIVE(node); /* we will persist */ 772 773 return (EOPNOTSUPP); 774 } 775 776 NG_H4_UNLOCK(sc); 777 778 NG_NODE_SET_PRIVATE(node, NULL); 779 780 IF_DRAIN(&sc->outq); 781 782 NG_NODE_UNREF(node); 783 bzero(sc, sizeof(*sc)); 784 kfree(sc, M_NETGRAPH_H4); 785 786 return (0); 787 } /* ng_h4_shutdown */ 788 789 /* 790 * Receive incoming data from Netgraph system. Put it on our 791 * output queue and start output if necessary. 792 */ 793 794 static int 795 ng_h4_rcvdata(hook_p hook, item_p item) 796 { 797 ng_h4_info_p sc = (ng_h4_info_p)NG_NODE_PRIVATE(NG_HOOK_NODE(hook)); 798 struct mbuf *m = NULL; 799 int qlen; 800 801 if (sc == NULL) 802 return (EHOSTDOWN); 803 804 if (hook != sc->hook) 805 panic("%s: hook != sc->hook", __func__); 806 807 NGI_GET_M(item, m); 808 NG_FREE_ITEM(item); 809 810 NG_H4_LOCK(sc); 811 812 if (IF_QFULL(&sc->outq)) { 813 NG_H4_ERR("%s: %s - dropping mbuf, len=%d\n", __func__, 814 NG_NODE_NAME(sc->node), m->m_pkthdr.len); 815 816 NG_H4_STAT_OERROR(sc->stat); 817 IF_DROP(&sc->outq); 818 819 NG_H4_UNLOCK(sc); 820 821 NG_FREE_M(m); 822 823 return (ENOBUFS); 824 } 825 826 NG_H4_INFO("%s: %s - queue mbuf, len=%d\n", __func__, 827 NG_NODE_NAME(sc->node), m->m_pkthdr.len); 828 829 IF_ENQUEUE(&sc->outq, m); 830 qlen = IF_QLEN(&sc->outq); 831 832 NG_H4_UNLOCK(sc); 833 834 /* 835 * If qlen > 1, then we should already have a scheduled callout 836 */ 837 838 if (qlen == 1) 839 ng_h4_start(sc->tp); 840 841 return (0); 842 } /* ng_h4_rcvdata */ 843 844 /* 845 * Receive control message 846 */ 847 848 static int 849 ng_h4_rcvmsg(node_p node, item_p item, hook_p lasthook) 850 { 851 ng_h4_info_p sc = (ng_h4_info_p) NG_NODE_PRIVATE(node); 852 struct ng_mesg *msg = NULL, *resp = NULL; 853 int error = 0; 854 855 if (sc == NULL) 856 return (EHOSTDOWN); 857 858 NGI_GET_MSG(item, msg); 859 NG_H4_LOCK(sc); 860 861 switch (msg->header.typecookie) { 862 case NGM_GENERIC_COOKIE: 863 switch (msg->header.cmd) { 864 case NGM_TEXT_STATUS: 865 NG_MKRESPONSE(resp, msg, NG_TEXTRESPONSE, M_WAITOK | M_NULLOK); 866 if (resp == NULL) 867 error = ENOMEM; 868 else 869 ksnprintf(resp->data, NG_TEXTRESPONSE, 870 "Hook: %s\n" \ 871 "Debug: %d\n" \ 872 "State: %d\n" \ 873 "Queue: [have:%d,max:%d]\n" \ 874 "Input: [got:%d,want:%d]", 875 (sc->hook != NULL)? NG_H4_HOOK : "", 876 sc->debug, 877 sc->state, 878 IF_QLEN(&sc->outq), 879 sc->outq.ifq_maxlen, 880 sc->got, 881 sc->want); 882 break; 883 884 default: 885 error = EINVAL; 886 break; 887 } 888 break; 889 890 case NGM_H4_COOKIE: 891 switch (msg->header.cmd) { 892 case NGM_H4_NODE_RESET: 893 IF_DRAIN(&sc->outq); 894 sc->state = NG_H4_W4_PKT_IND; 895 sc->want = 1; 896 sc->got = 0; 897 break; 898 899 case NGM_H4_NODE_GET_STATE: 900 NG_MKRESPONSE(resp, msg, sizeof(ng_h4_node_state_ep), 901 M_WAITOK | M_NULLOK); 902 if (resp == NULL) 903 error = ENOMEM; 904 else 905 *((ng_h4_node_state_ep *)(resp->data)) = 906 sc->state; 907 break; 908 909 case NGM_H4_NODE_GET_DEBUG: 910 NG_MKRESPONSE(resp, msg, sizeof(ng_h4_node_debug_ep), 911 M_WAITOK | M_NULLOK); 912 if (resp == NULL) 913 error = ENOMEM; 914 else 915 *((ng_h4_node_debug_ep *)(resp->data)) = 916 sc->debug; 917 break; 918 919 case NGM_H4_NODE_SET_DEBUG: 920 if (msg->header.arglen != sizeof(ng_h4_node_debug_ep)) 921 error = EMSGSIZE; 922 else 923 sc->debug = 924 *((ng_h4_node_debug_ep *)(msg->data)); 925 break; 926 927 case NGM_H4_NODE_GET_QLEN: 928 NG_MKRESPONSE(resp, msg, sizeof(ng_h4_node_qlen_ep), 929 M_WAITOK | M_NULLOK); 930 if (resp == NULL) 931 error = ENOMEM; 932 else 933 *((ng_h4_node_qlen_ep *)(resp->data)) = 934 sc->outq.ifq_maxlen; 935 break; 936 937 case NGM_H4_NODE_SET_QLEN: 938 if (msg->header.arglen != sizeof(ng_h4_node_qlen_ep)) 939 error = EMSGSIZE; 940 else if (*((ng_h4_node_qlen_ep *)(msg->data)) <= 0) 941 error = EINVAL; 942 else 943 sc->outq.ifq_maxlen = 944 *((ng_h4_node_qlen_ep *)(msg->data)); 945 break; 946 947 case NGM_H4_NODE_GET_STAT: 948 NG_MKRESPONSE(resp, msg, sizeof(ng_h4_node_stat_ep), 949 M_WAITOK | M_NULLOK); 950 if (resp == NULL) 951 error = ENOMEM; 952 else 953 bcopy(&sc->stat, resp->data, 954 sizeof(ng_h4_node_stat_ep)); 955 break; 956 957 case NGM_H4_NODE_RESET_STAT: 958 NG_H4_STAT_RESET(sc->stat); 959 break; 960 961 default: 962 error = EINVAL; 963 break; 964 } 965 break; 966 967 default: 968 error = EINVAL; 969 break; 970 } 971 972 NG_H4_UNLOCK(sc); 973 974 NG_RESPOND_MSG(error, node, item, resp); 975 NG_FREE_MSG(msg); 976 977 return (error); 978 } /* ng_h4_rcvmsg */ 979 980 /* 981 * Timeout processing function. 982 * We still have data to output to the device, so try sending more. 983 */ 984 985 static void 986 ng_h4_process_timeout(node_p node, hook_p hook, void *arg1, int arg2) 987 { 988 ng_h4_info_p sc = (ng_h4_info_p) NG_NODE_PRIVATE(node); 989 990 ng_h4_start(sc->tp); 991 } /* ng_h4_process_timeout */ 992 993 /* 994 * Handle loading and unloading for this node type 995 */ 996 997 static int 998 ng_h4_mod_event(module_t mod, int event, void *data) 999 { 1000 static int ng_h4_ldisc; 1001 int error = 0; 1002 1003 switch (event) { 1004 case MOD_LOAD: 1005 /* Register line discipline */ 1006 crit_enter(); 1007 ng_h4_ldisc = ldisc_register(BTUARTDISC, &ng_h4_disc); 1008 crit_exit(); 1009 1010 if (ng_h4_ldisc < 0) { 1011 kprintf("%s: can't register H4 line discipline\n", 1012 __func__); 1013 error = EIO; 1014 } 1015 break; 1016 1017 case MOD_UNLOAD: 1018 /* Unregister line discipline */ 1019 crit_enter(); 1020 ldisc_deregister(ng_h4_ldisc); 1021 crit_exit(); 1022 break; 1023 1024 default: 1025 error = EOPNOTSUPP; 1026 break; 1027 } 1028 1029 return (error); 1030 } /* ng_h4_mod_event */ 1031 1032