sys/dev/misc/dcons/dcons_os.c

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