sys/netgraph7/bluetooth/drivers/h4/ng_h4.c

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