sys/dev/misc/dcons/dcons_os.c

   1 /*
   2  * (MPSAFE)
   3  *
   4  * Copyright (C) 2003,2004
   5  *      Hidetoshi Shimokawa. 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  * 3. All advertising materials mentioning features or use of this software
  16  *    must display the following acknowledgement:
  17  *
  18  *      This product includes software developed by Hidetoshi Shimokawa.
  19  *
  20  * 4. Neither the name of the author nor the names of its contributors
  21  *    may be used to endorse or promote products derived from this software
  22  *    without specific prior written permission.
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  34  * SUCH DAMAGE.
  35  *
  36  * $FreeBSD: src/sys/dev/dcons/dcons_os.c,v 1.4 2004/10/24 12:41:04 simokawa Exp $
  37  */
  38
  39 #include <sys/param.h>
  40 #if __FreeBSD_version >= 502122
  41 #include <sys/kdb.h>
  42 #include <gdb/gdb.h>
  43 #endif
  44 #include <sys/kernel.h>
  45 #include <sys/module.h>
  46 #include <sys/systm.h>
  47 #include <sys/types.h>
  48 #include <sys/conf.h>
  49 #include <sys/cons.h>
  50 #include <sys/consio.h>
  51 #include <sys/tty.h>
  52 #include <sys/malloc.h>
  53 #include <sys/proc.h>
  54 #include <sys/priv.h>
  55 #include <sys/thread2.h>
  56 #include <sys/ucred.h>
  57 #include <sys/bus.h>
  58
  59 #include "dcons.h"
  60 #include "dcons_os.h"
  61
  62 #include <ddb/ddb.h>
  63 #include <sys/reboot.h>
  64
  65 #include <sys/sysctl.h>
  66
  67 #include <vm/vm.h>
  68 #include <vm/vm_param.h>
  69 #include <vm/pmap.h>
  70
  71 #include "opt_ddb.h"
  72 #include "opt_comconsole.h"
  73 #include "opt_dcons.h"
  74
  75 #ifndef DCONS_POLL_HZ
  76 #define DCONS_POLL_HZ   100
  77 #endif
  78
  79 #ifndef DCONS_BUF_SIZE
  80 #define DCONS_BUF_SIZE (16*1024)
  81 #endif
  82
  83 #ifndef DCONS_FORCE_CONSOLE
  84 #define DCONS_FORCE_CONSOLE     0       /* Mostly for FreeBSD-4/DragonFly */
  85 #endif
  86
  87 #ifndef DCONS_FORCE_GDB
  88 #define DCONS_FORCE_GDB 1
  89 #endif
  90
  91 static d_open_t         dcons_open;
  92 static d_close_t        dcons_close;
  93 static d_ioctl_t        dcons_ioctl;
  94
  95 static struct dev_ops dcons_ops = {
  96         { "dcons", 0, D_TTY },
  97         .d_open =       dcons_open,
  98         .d_close =      dcons_close,
  99         .d_read =       ttyread,
 100         .d_write =      ttywrite,
 101         .d_ioctl =      dcons_ioctl,
 102         .d_kqfilter =   ttykqfilter,
 103         .d_revoke =     ttyrevoke
 104 };
 105
 106 #ifndef KLD_MODULE
 107 static char bssbuf[DCONS_BUF_SIZE];     /* buf in bss */
 108 #endif
 109
 110 /* global data */
 111 static struct dcons_global dg;
 112 struct dcons_global *dcons_conf;
 113 static int poll_hz = DCONS_POLL_HZ;
 114
 115 static struct dcons_softc sc[DCONS_NPORT];
 116
 117 SYSCTL_NODE(_kern, OID_AUTO, dcons, CTLFLAG_RD, 0, "Dumb Console");
 118 SYSCTL_INT(_kern_dcons, OID_AUTO, poll_hz, CTLFLAG_RW, &poll_hz, 0,
 119                                 "dcons polling rate");
 120
 121 static int drv_init = 0;
 122 static struct callout dcons_callout;
 123 struct dcons_buf *dcons_buf;            /* for local dconschat */
 124
 125 #ifdef __DragonFly__
 126 #define DEV     cdev_t
 127 #define THREAD  d_thread_t
 128 #elif __FreeBSD_version < 500000
 129 #define DEV     cdev_t
 130 #define THREAD  struct proc
 131 #else
 132 #define DEV     struct cdev *
 133 #define THREAD  struct thread
 134 #endif
 135
 136
 137 static void     dcons_tty_start(struct tty *);
 138 static int      dcons_tty_param(struct tty *, struct termios *);
 139 static void     dcons_timeout(void *);
 140 static int      dcons_drv_init(int);
 141
 142 static cn_probe_t       dcons_cnprobe;
 143 static cn_init_t        dcons_cninit;
 144 static cn_init_fini_t   dcons_cninit_fini;
 145 static cn_getc_t        dcons_cngetc;
 146 static cn_checkc_t      dcons_cncheckc;
 147 static cn_putc_t        dcons_cnputc;
 148
 149 CONS_DRIVER(dcons, dcons_cnprobe, dcons_cninit, dcons_cninit_fini,
 150             NULL, dcons_cngetc, dcons_cncheckc, dcons_cnputc, NULL);
 151
 152 #if __FreeBSD_version >= 502122
 153 static gdb_probe_f dcons_dbg_probe;
 154 static gdb_init_f dcons_dbg_init;
 155 static gdb_term_f dcons_dbg_term;
 156 static gdb_getc_f dcons_dbg_getc;
 157 static gdb_checkc_f dcons_dbg_checkc;
 158 static gdb_putc_f dcons_dbg_putc;
 159
 160 GDB_DBGPORT(dcons, dcons_dbg_probe, dcons_dbg_init, dcons_dbg_term,
 161     dcons_dbg_checkc, dcons_dbg_getc, dcons_dbg_putc);
 162
 163 extern struct gdb_dbgport *gdb_cur;
 164 #endif
 165
 166 #if (KDB || DDB) && ALT_BREAK_TO_DEBUGGER
 167 static int
 168 dcons_check_break(struct dcons_softc *dc, int c)
 169 {
 170         if (c < 0)
 171                 return (c);
 172
 173         lwkt_gettoken(&tty_token);
 174 #if __FreeBSD_version >= 502122
 175         if (kdb_alt_break(c, &dc->brk_state)) {
 176                 if ((dc->flags & DC_GDB) != 0) {
 177                         if (gdb_cur == &dcons_gdb_dbgport) {
 178                                 kdb_dbbe_select("gdb");
 179                                 breakpoint();
 180                         }
 181                 } else
 182                         breakpoint();
 183         }
 184 #else
 185         switch (dc->brk_state) {
 186         case STATE1:
 187                 if (c == KEY_TILDE)
 188                         dc->brk_state = STATE2;
 189                 else
 190                         dc->brk_state = STATE0;
 191                 break;
 192         case STATE2:
 193                 dc->brk_state = STATE0;
 194                 if (c == KEY_CTRLB) {
 195 #if DCONS_FORCE_GDB
 196                         if (dc->flags & DC_GDB)
 197                                 boothowto |= RB_GDB;
 198 #endif
 199                         breakpoint();
 200                 }
 201         }
 202         if (c == KEY_CR)
 203                 dc->brk_state = STATE1;
 204 #endif
 205         lwkt_reltoken(&tty_token);
 206         return (c);
 207 }
 208 #else
 209 #define dcons_check_break(dc, c)        (c)
 210 #endif
 211
 212 static int
 213 dcons_os_checkc(struct dcons_softc *dc)
 214 {
 215         int c;
 216
 217         lwkt_gettoken(&tty_token);
 218         if (dg.dma_tag != NULL)
 219                 bus_dmamap_sync(dg.dma_tag, dg.dma_map, BUS_DMASYNC_POSTREAD);
 220
 221         c = dcons_check_break(dc, dcons_checkc(dc));
 222
 223         if (dg.dma_tag != NULL)
 224                 bus_dmamap_sync(dg.dma_tag, dg.dma_map, BUS_DMASYNC_PREREAD);
 225
 226         lwkt_reltoken(&tty_token);
 227         return (c);
 228 }
 229
 230 static int
 231 dcons_os_getc(struct dcons_softc *dc)
 232 {
 233         int c;
 234
 235         while ((c = dcons_os_checkc(dc)) == -1);
 236
 237         return (c & 0xff);
 238 }
 239
 240 static void
 241 dcons_os_putc(struct dcons_softc *dc, int c)
 242 {
 243         if (dg.dma_tag != NULL)
 244                 bus_dmamap_sync(dg.dma_tag, dg.dma_map, BUS_DMASYNC_POSTWRITE);
 245
 246         dcons_putc(dc, c);
 247
 248         if (dg.dma_tag != NULL)
 249                 bus_dmamap_sync(dg.dma_tag, dg.dma_map, BUS_DMASYNC_PREWRITE);
 250 }
 251 static int
 252 dcons_open(struct dev_open_args *ap)
 253 {
 254         cdev_t dev = ap->a_head.a_dev;
 255         struct tty *tp;
 256         int unit, error;
 257
 258         unit = minor(dev);
 259         if (unit != 0)
 260                 return (ENXIO);
 261
 262         lwkt_gettoken(&tty_token);
 263         tp = dev->si_tty = ttymalloc(dev->si_tty);
 264         tp->t_oproc = dcons_tty_start;
 265         tp->t_param = dcons_tty_param;
 266         tp->t_stop = nottystop;
 267         tp->t_dev = dev;
 268
 269         error = 0;
 270
 271         crit_enter();
 272         if ((tp->t_state & TS_ISOPEN) == 0) {
 273                 tp->t_state |= TS_CARR_ON;
 274                 ttychars(tp);
 275                 tp->t_iflag = TTYDEF_IFLAG;
 276                 tp->t_oflag = TTYDEF_OFLAG;
 277                 tp->t_cflag = TTYDEF_CFLAG|CLOCAL;
 278                 tp->t_lflag = TTYDEF_LFLAG;
 279                 tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED;
 280                 ttsetwater(tp);
 281         } else if ((tp->t_state & TS_XCLUDE) && priv_check_cred(ap->a_cred, PRIV_ROOT, 0)) {
 282                 crit_exit();
 283                 lwkt_reltoken(&tty_token);
 284                 return (EBUSY);
 285         }
 286         crit_exit();
 287
 288 #if __FreeBSD_version < 502113
 289         error = (*linesw[tp->t_line].l_open)(dev, tp);
 290 #else
 291         error = ttyld_open(tp, dev);
 292 #endif
 293         lwkt_reltoken(&tty_token);
 294         return (error);
 295 }
 296
 297 static int
 298 dcons_close(struct dev_close_args *ap)
 299 {
 300         cdev_t dev = ap->a_head.a_dev;
 301         int     unit;
 302         struct  tty *tp;
 303
 304         unit = minor(dev);
 305         if (unit != 0)
 306                 return (ENXIO);
 307
 308         lwkt_gettoken(&tty_token);
 309         tp = dev->si_tty;
 310         if (tp->t_state & TS_ISOPEN) {
 311                 (*linesw[tp->t_line].l_close)(tp, ap->a_fflag);
 312                 ttyclose(tp);
 313         }
 314         lwkt_reltoken(&tty_token);
 315
 316         return (0);
 317 }
 318
 319 static int
 320 dcons_ioctl(struct dev_ioctl_args *ap)
 321 {
 322         cdev_t dev = ap->a_head.a_dev;
 323         int     unit;
 324         struct  tty *tp;
 325         int     error;
 326
 327         unit = minor(dev);
 328         if (unit != 0)
 329                 return (ENXIO);
 330
 331         lwkt_gettoken(&tty_token);
 332         tp = dev->si_tty;
 333         error = (*linesw[tp->t_line].l_ioctl)(tp, ap->a_cmd, ap->a_data, ap->a_fflag, ap->a_cred);
 334         if (error != ENOIOCTL) {
 335                 lwkt_reltoken(&tty_token);
 336                 return (error);
 337         }
 338
 339         error = ttioctl(tp, ap->a_cmd, ap->a_data, ap->a_fflag);
 340         if (error != ENOIOCTL) {
 341                 lwkt_reltoken(&tty_token);
 342                 return (error);
 343         }
 344
 345         lwkt_reltoken(&tty_token);
 346         return (ENOTTY);
 347 }
 348
 349 static int
 350 dcons_tty_param(struct tty *tp, struct termios *t)
 351 {
 352         lwkt_gettoken(&tty_token);
 353         tp->t_ispeed = t->c_ispeed;
 354         tp->t_ospeed = t->c_ospeed;
 355         tp->t_cflag = t->c_cflag;
 356         lwkt_reltoken(&tty_token);
 357         return 0;
 358 }
 359
 360 static void
 361 dcons_tty_start(struct tty *tp)
 362 {
 363         struct dcons_softc *dc;
 364
 365         lwkt_gettoken(&tty_token);
 366         dc = (struct dcons_softc *)tp->t_dev->si_drv1;
 367         crit_enter();
 368         if (tp->t_state & (TS_TIMEOUT | TS_TTSTOP)) {
 369                 ttwwakeup(tp);
 370                 lwkt_reltoken(&tty_token);
 371                 return;
 372         }
 373
 374         tp->t_state |= TS_BUSY;
 375         while (tp->t_outq.c_cc != 0)
 376                 dcons_os_putc(dc, clist_getc(&tp->t_outq));
 377         tp->t_state &= ~TS_BUSY;
 378
 379         ttwwakeup(tp);
 380         crit_exit();
 381         lwkt_reltoken(&tty_token);
 382 }
 383
 384 static void
 385 dcons_timeout(void *v)
 386 {
 387         struct  tty *tp;
 388         struct dcons_softc *dc;
 389         int i, c, polltime;
 390
 391         lwkt_gettoken(&tty_token);
 392         for (i = 0; i < DCONS_NPORT; i ++) {
 393                 dc = &sc[i];
 394                 tp = ((DEV)dc->dev)->si_tty;
 395                 while ((c = dcons_os_checkc(dc)) != -1)
 396                         if (tp->t_state & TS_ISOPEN)
 397 #if __FreeBSD_version < 502113
 398                                 (*linesw[tp->t_line].l_rint)(c, tp);
 399 #else
 400                                 ttyld_rint(tp, c);
 401 #endif
 402         }
 403         polltime = hz / poll_hz;
 404         if (polltime < 1)
 405                 polltime = 1;
 406         callout_reset(&dcons_callout, polltime, dcons_timeout, tp);
 407         lwkt_reltoken(&tty_token);
 408 }
 409
 410 static void
 411 dcons_cnprobe(struct consdev *cp)
 412 {
 413 #ifdef __DragonFly__
 414         cp->cn_probegood = 1;
 415 #elif __FreeBSD_version >= 501109
 416         ksprintf(cp->cn_name, "dcons");
 417 #else
 418         cp->cn_dev = makedev(CDEV_MAJOR, DCONS_CON);
 419 #endif
 420 #if DCONS_FORCE_CONSOLE
 421         cp->cn_pri = CN_REMOTE;
 422 #else
 423         cp->cn_pri = CN_NORMAL;
 424 #endif
 425 }
 426
 427 static void
 428 dcons_cninit(struct consdev *cp)
 429 {
 430         dcons_drv_init(0);
 431 #if CONS_NODEV
 432         cp->cn_arg
 433 #else
 434         cp->cn_private
 435 #endif
 436                 = (void *)&sc[DCONS_CON]; /* share port0 with unit0 */
 437 }
 438
 439 static void
 440 dcons_cninit_fini(struct consdev *cp)
 441 {
 442         cp->cn_dev = make_dev(&dcons_ops, DCONS_CON,
 443                               UID_ROOT, GID_WHEEL, 0600, "dcons");
 444 }
 445
 446 #if CONS_NODEV
 447 static int
 448 dcons_cngetc(struct consdev *cp)
 449 {
 450         struct dcons_softc *dc = (struct dcons_softc *)cp->cn_arg;
 451         return (dcons_os_getc(dc));
 452 }
 453 static int
 454 dcons_cncheckc(struct consdev *cp)
 455 {
 456         struct dcons_softc *dc = (struct dcons_softc *)cp->cn_arg;
 457         return (dcons_os_checkc(dc));
 458 }
 459 static void
 460 dcons_cnputc(struct consdev *cp, int c)
 461 {
 462         struct dcons_softc *dc = (struct dcons_softc *)cp->cn_arg;
 463         dcons_os_putc(dc, c);
 464 }
 465 #else
 466 static int
 467 dcons_cngetc(void *private)
 468 {
 469         struct dcons_softc *dc = (struct dcons_softc *)private;
 470         return (dcons_os_getc(dc));
 471 }
 472 static int
 473 dcons_cncheckc(void *private)
 474 {
 475         struct dcons_softc *dc = (struct dcons_softc *)private;
 476         return (dcons_os_checkc(dc));
 477 }
 478 static void
 479 dcons_cnputc(void *private, int c)
 480 {
 481         struct dcons_softc *dc = (struct dcons_softc *)private;
 482         dcons_os_putc(dc, c);
 483 }
 484 #endif
 485
 486 static int
 487 dcons_drv_init(int stage)
 488 {
 489 #ifdef __i386__
 490         quad_t addr, size;
 491 #endif
 492
 493         if (drv_init)
 494                 return(drv_init);
 495
 496         drv_init = -1;
 497
 498         bzero(&dg, sizeof(dg));
 499         dcons_conf = &dg;
 500         dg.cdev = &dcons_consdev;
 501         dg.buf = NULL;
 502         dg.size = DCONS_BUF_SIZE;
 503
 504 #ifdef __i386__
 505         if (kgetenv_quad("dcons.addr", &addr) > 0 &&
 506             kgetenv_quad("dcons.size", &size) > 0) {
 507                 vm_paddr_t pa;
 508                 /*
 509                  * Allow read/write access to dcons buffer.
 510                  */
 511                 for (pa = trunc_page(addr); pa < addr + size; pa += PAGE_SIZE)
 512                         pmap_kmodify_rw((vm_offset_t)(KERNBASE + pa));
 513                 cpu_invltlb();
 514                 /* XXX P to V */
 515                 dg.buf = (struct dcons_buf *)(vm_offset_t)(KERNBASE + addr);
 516                 dg.size = size;
 517                 if (dcons_load_buffer(dg.buf, dg.size, sc) < 0)
 518                         dg.buf = NULL;
 519         }
 520 #endif
 521         if (dg.buf != NULL)
 522                 goto ok;
 523
 524 #ifndef KLD_MODULE
 525         if (stage == 0) { /* XXX or cold */
 526                 /*
 527                  * DCONS_FORCE_CONSOLE == 1 and statically linked.
 528                  * called from cninit(). can't use contigmalloc yet .
 529                  */
 530                 dg.buf = (struct dcons_buf *) bssbuf;
 531                 dcons_init(dg.buf, dg.size, sc);
 532         } else
 533 #endif
 534         {
 535                 /*
 536                  * DCONS_FORCE_CONSOLE == 0 or kernel module case.
 537                  * if the module is loaded after boot,
 538                  * bssbuf could be non-continuous.
 539                  */
 540                 dg.buf = (struct dcons_buf *) contigmalloc(dg.size,
 541                         M_DEVBUF, 0, 0x10000, 0xffffffff, PAGE_SIZE, 0ul);
 542                 dcons_init(dg.buf, dg.size, sc);
 543         }
 544
 545 ok:
 546         dcons_buf = dg.buf;
 547
 548 #if DDB && DCONS_FORCE_GDB
 549         if (gdb_tab == NULL) {
 550                 gdb_tab = &dcons_consdev;
 551                 dcons_consdev.cn_gdbprivate = &sc[DCONS_GDB];
 552         }
 553 #endif
 554         drv_init = 1;
 555
 556         return 0;
 557 }
 558
 559 /*
 560  * NOTE: Must be called with tty_token held
 561  */
 562 static int
 563 dcons_attach_port(int port, char *name, int flags)
 564 {
 565         struct dcons_softc *dc;
 566         struct tty *tp;
 567         DEV dev;
 568
 569         ASSERT_LWKT_TOKEN_HELD(&tty_token);
 570         dc = &sc[port];
 571         dc->flags = flags;
 572         dev = make_dev(&dcons_ops, port,
 573                         UID_ROOT, GID_WHEEL, 0600, name);
 574         dc->dev = (void *)dev;
 575         tp = ttymalloc(NULL);
 576
 577         dev->si_drv1 = (void *)dc;
 578         dev->si_tty = tp;
 579
 580         tp->t_oproc = dcons_tty_start;
 581         tp->t_param = dcons_tty_param;
 582         tp->t_stop = nottystop;
 583         tp->t_dev = dc->dev;
 584
 585         return(0);
 586 }
 587
 588 /*
 589  * NOTE: Must be called with tty_token held
 590  */
 591 static int
 592 dcons_attach(void)
 593 {
 594         int polltime;
 595
 596         ASSERT_LWKT_TOKEN_HELD(&tty_token);
 597         dcons_attach_port(DCONS_CON, "dcons", 0);
 598         dcons_attach_port(DCONS_GDB, "dgdb", DC_GDB);
 599 #if __FreeBSD_version < 500000
 600         callout_init_mp(&dcons_callout);
 601 #else
 602         callout_init(&dcons_callout, 0);
 603 #endif
 604         polltime = hz / poll_hz;
 605         if (polltime < 1)
 606                 polltime = 1;
 607         callout_reset(&dcons_callout, polltime, dcons_timeout, NULL);
 608         return(0);
 609 }
 610
 611 /*
 612  * NOTE: Must be called with tty_token held
 613  */
 614 static int
 615 dcons_detach(int port)
 616 {
 617         struct  tty *tp;
 618         struct dcons_softc *dc;
 619
 620         ASSERT_LWKT_TOKEN_HELD(&tty_token);
 621         dc = &sc[port];
 622
 623         tp = ((DEV)dc->dev)->si_tty;
 624
 625         if (tp->t_state & TS_ISOPEN) {
 626                 kprintf("dcons: still opened\n");
 627 #if __FreeBSD_version < 502113
 628                 (*linesw[tp->t_line].l_close)(tp, 0);
 629                 ttyclose(tp);
 630 #else
 631                 ttyld_close(tp, 0);
 632                 tty_close(tp);
 633 #endif
 634         }
 635         /* XXX
 636          * must wait until all device are closed.
 637          */
 638 #ifdef __DragonFly__
 639         tsleep((void *)dc, 0, "dcodtc", hz/4);
 640 #else
 641         tsleep((void *)dc, PWAIT, "dcodtc", hz/4);
 642 #endif
 643         destroy_dev(dc->dev);
 644
 645         return(0);
 646 }
 647
 648
 649 /* cnXXX works only for FreeBSD-5 */
 650 static int
 651 dcons_modevent(module_t mode, int type, void *data)
 652 {
 653         int err = 0, ret;
 654
 655         lwkt_gettoken(&tty_token);
 656         switch (type) {
 657         case MOD_LOAD:
 658                 ret = dcons_drv_init(1);
 659                 dcons_attach();
 660 #if __FreeBSD_version >= 500000
 661                 if (ret == 0) {
 662                         dcons_cnprobe(&dcons_consdev);
 663                         dcons_cninit(&dcons_consdev);
 664                         cnadd(&dcons_consdev);
 665                 }
 666 #endif
 667                 break;
 668         case MOD_UNLOAD:
 669                 kprintf("dcons: unload\n");
 670                 callout_stop(&dcons_callout);
 671 #if __FreeBSD_version < 502122
 672 #if DDB && DCONS_FORCE_GDB
 673 #if CONS_NODEV
 674                 gdb_arg = NULL;
 675 #else
 676                 if (gdb_tab == &dcons_consdev)
 677                         gdb_tab = NULL;
 678 #endif
 679 #endif
 680 #endif
 681 #if __FreeBSD_version >= 500000
 682                 cnremove(&dcons_consdev);
 683 #endif
 684                 dcons_detach(DCONS_CON);
 685                 dcons_detach(DCONS_GDB);
 686                 dg.buf->magic = 0;
 687
 688                 contigfree(dg.buf, DCONS_BUF_SIZE, M_DEVBUF);
 689
 690                 break;
 691         case MOD_SHUTDOWN:
 692                 dg.buf->magic = 0;
 693                 break;
 694         default:
 695                 err = EOPNOTSUPP;
 696                 break;
 697         }
 698         lwkt_reltoken(&tty_token);
 699         return(err);
 700 }
 701
 702 #if __FreeBSD_version >= 502122
 703 /* Debugger interface */
 704
 705 static int
 706 dcons_dbg_probe(void)
 707 {
 708         return(DCONS_FORCE_GDB);
 709 }
 710
 711 static void
 712 dcons_dbg_init(void)
 713 {
 714 }
 715
 716 static void
 717 dcons_dbg_term(void)
 718 {
 719 }
 720
 721 static void
 722 dcons_dbg_putc(int c)
 723 {
 724         struct dcons_softc *dc = &sc[DCONS_GDB];
 725         dcons_os_putc(dc, c);
 726 }
 727
 728 static int
 729 dcons_dbg_checkc(void)
 730 {
 731         struct dcons_softc *dc = &sc[DCONS_GDB];
 732         return (dcons_os_checkc(dc));
 733 }
 734
 735 static int
 736 dcons_dbg_getc(void)
 737 {
 738         struct dcons_softc *dc = &sc[DCONS_GDB];
 739         return (dcons_os_getc(dc));
 740 }
 741 #endif
 742
 743 DEV_MODULE(dcons, dcons_modevent, NULL);
 744 MODULE_VERSION(dcons, DCONS_VERSION);