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