dcons_os.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /*-
    2  * SPDX-License-Identifier: BSD-4-Clause
    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$
   37  */
   38 
   39 #include <sys/param.h>
   40 #include <sys/eventhandler.h>
   41 #include <sys/kdb.h>
   42 #include <gdb/gdb.h>
   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/priv.h>
   53 #include <sys/proc.h>
   54 #include <sys/ucred.h>
   55 
   56 #include <machine/atomic.h>
   57 #include <machine/bus.h>
   58 
   59 #include <dev/dcons/dcons.h>
   60 #include <dev/dcons/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_dcons.h"
   72 #include "opt_kdb.h"
   73 #include "opt_gdb.h"
   74 #include "opt_ddb.h"
   75 
   76 
   77 #ifndef DCONS_POLL_HZ
   78 #define DCONS_POLL_HZ   25
   79 #endif
   80 
   81 #ifndef DCONS_POLL_IDLE
   82 #define DCONS_POLL_IDLE 256
   83 #endif
   84 
   85 #ifndef DCONS_BUF_SIZE
   86 #define DCONS_BUF_SIZE (16*1024)
   87 #endif
   88 
   89 #ifndef DCONS_FORCE_CONSOLE
   90 #define DCONS_FORCE_CONSOLE     0       /* Mostly for FreeBSD-4/DragonFly */
   91 #endif
   92 
   93 #ifndef KLD_MODULE
   94 static char bssbuf[DCONS_BUF_SIZE];     /* buf in bss */
   95 #endif
   96 
   97 /* global data */
   98 static struct dcons_global dg;
   99 struct dcons_global *dcons_conf;
  100 static int poll_hz = DCONS_POLL_HZ;
  101 static u_int poll_idle = DCONS_POLL_HZ * DCONS_POLL_IDLE;
  102 
  103 static struct dcons_softc sc[DCONS_NPORT];
  104 
  105 static SYSCTL_NODE(_kern, OID_AUTO, dcons, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
  106     "Dumb Console");
  107 SYSCTL_INT(_kern_dcons, OID_AUTO, poll_hz, CTLFLAG_RW, &poll_hz, 0,
  108                                 "dcons polling rate");
  109 
  110 static int drv_init = 0;
  111 static struct callout dcons_callout;
  112 struct dcons_buf *dcons_buf;            /* for local dconschat */
  113 
  114 static void     dcons_timeout(void *);
  115 static int      dcons_drv_init(int);
  116 
  117 static cn_probe_t       dcons_cnprobe;
  118 static cn_init_t        dcons_cninit;
  119 static cn_term_t        dcons_cnterm;
  120 static cn_getc_t        dcons_cngetc;
  121 static cn_putc_t        dcons_cnputc;
  122 static cn_grab_t        dcons_cngrab;
  123 static cn_ungrab_t      dcons_cnungrab;
  124 
  125 CONSOLE_DRIVER(dcons);
  126 
  127 #if defined(GDB)
  128 static gdb_probe_f      dcons_dbg_probe;
  129 static gdb_init_f       dcons_dbg_init;
  130 static gdb_term_f       dcons_dbg_term;
  131 static gdb_getc_f       dcons_dbg_getc;
  132 static gdb_putc_f       dcons_dbg_putc;
  133 
  134 GDB_DBGPORT(dcons, dcons_dbg_probe, dcons_dbg_init, dcons_dbg_term,
  135     dcons_dbg_getc, dcons_dbg_putc);
  136 
  137 extern struct gdb_dbgport *gdb_cur;
  138 #endif
  139 
  140 static tsw_outwakeup_t dcons_outwakeup;
  141 static tsw_free_t      dcons_free;
  142 
  143 static struct ttydevsw dcons_ttydevsw = {
  144         .tsw_flags      = TF_NOPREFIX,
  145         .tsw_outwakeup  = dcons_outwakeup,
  146         .tsw_free       = dcons_free,
  147 };
  148 
  149 static int dcons_close_refs;
  150 
  151 #if (defined(GDB) || defined(DDB))
  152 static int
  153 dcons_check_break(struct dcons_softc *dc, int c)
  154 {
  155 
  156         if (c < 0)
  157                 return (c);
  158 
  159 #ifdef GDB
  160         if ((dc->flags & DC_GDB) != 0 && gdb_cur == &dcons_gdb_dbgport)
  161                 kdb_alt_break_gdb(c, &dc->brk_state);
  162         else
  163 #endif
  164                 kdb_alt_break(c, &dc->brk_state);
  165 
  166         return (c);
  167 }
  168 #else
  169 #define dcons_check_break(dc, c)        (c)
  170 #endif
  171 
  172 static int
  173 dcons_os_checkc_nopoll(struct dcons_softc *dc)
  174 {
  175         int c;
  176 
  177         if (dg.dma_tag != NULL)
  178                 bus_dmamap_sync(dg.dma_tag, dg.dma_map, BUS_DMASYNC_POSTREAD);
  179 
  180         c = dcons_check_break(dc, dcons_checkc(dc));
  181 
  182         if (dg.dma_tag != NULL)
  183                 bus_dmamap_sync(dg.dma_tag, dg.dma_map, BUS_DMASYNC_PREREAD);
  184 
  185         return (c);
  186 }
  187 
  188 static int
  189 dcons_os_checkc(struct dcons_softc *dc)
  190 {
  191         EVENTHANDLER_INVOKE(dcons_poll, 0);
  192         return (dcons_os_checkc_nopoll(dc));
  193 }
  194 
  195 static void
  196 dcons_os_putc(struct dcons_softc *dc, int c)
  197 {
  198         if (dg.dma_tag != NULL)
  199                 bus_dmamap_sync(dg.dma_tag, dg.dma_map, BUS_DMASYNC_POSTWRITE);
  200 
  201         dcons_putc(dc, c);
  202 
  203         if (dg.dma_tag != NULL)
  204                 bus_dmamap_sync(dg.dma_tag, dg.dma_map, BUS_DMASYNC_PREWRITE);
  205 }
  206 
  207 static void
  208 dcons_free(void *xsc __unused)
  209 {
  210 
  211         /* Our deferred free has arrived, now we're waiting for one fewer. */
  212         atomic_subtract_rel_int(&dcons_close_refs, 1);
  213 }
  214 
  215 static void
  216 dcons_outwakeup(struct tty *tp)
  217 {
  218         struct dcons_softc *dc;
  219         char ch;
  220 
  221         dc = tty_softc(tp);
  222 
  223         while (ttydisc_getc(tp, &ch, sizeof ch) != 0)
  224                 dcons_os_putc(dc, ch);
  225 }
  226 
  227 static void
  228 dcons_timeout(void *v)
  229 {
  230         struct  tty *tp;
  231         struct dcons_softc *dc;
  232         int i, c, polltime;
  233 
  234         for (i = 0; i < DCONS_NPORT; i ++) {
  235                 dc = &sc[i];
  236                 tp = dc->tty;
  237 
  238                 tty_lock(tp);
  239                 while ((c = dcons_os_checkc_nopoll(dc)) != -1) {
  240                         ttydisc_rint(tp, c, 0);
  241                         poll_idle = 0;
  242                 }
  243                 ttydisc_rint_done(tp);
  244                 tty_unlock(tp);
  245         }
  246         poll_idle++;
  247         polltime = hz;
  248         if (poll_idle <= (poll_hz * DCONS_POLL_IDLE))
  249                 polltime /= poll_hz;
  250         callout_reset(&dcons_callout, polltime, dcons_timeout, tp);
  251 }
  252 
  253 static void
  254 dcons_cnprobe(struct consdev *cp)
  255 {
  256         sprintf(cp->cn_name, "dcons");
  257 #if DCONS_FORCE_CONSOLE
  258         cp->cn_pri = CN_REMOTE;
  259 #else
  260         cp->cn_pri = CN_NORMAL;
  261 #endif
  262 }
  263 
  264 static void
  265 dcons_cninit(struct consdev *cp)
  266 {
  267         dcons_drv_init(0);
  268         cp->cn_arg = (void *)&sc[DCONS_CON]; /* share port0 with unit0 */
  269 }
  270 
  271 static void
  272 dcons_cnterm(struct consdev *cp)
  273 {
  274 }
  275 
  276 static void
  277 dcons_cngrab(struct consdev *cp)
  278 {
  279 }
  280 
  281 static void
  282 dcons_cnungrab(struct consdev *cp)
  283 {
  284 }
  285 
  286 static int
  287 dcons_cngetc(struct consdev *cp)
  288 {
  289         struct dcons_softc *dc = (struct dcons_softc *)cp->cn_arg;
  290         return (dcons_os_checkc(dc));
  291 }
  292 
  293 static void
  294 dcons_cnputc(struct consdev *cp, int c)
  295 {
  296         struct dcons_softc *dc = (struct dcons_softc *)cp->cn_arg;
  297         dcons_os_putc(dc, c);
  298 }
  299 
  300 static int
  301 dcons_drv_init(int stage)
  302 {
  303 #if defined(__i386__) || defined(__amd64__)
  304         quad_t addr, size;
  305 #endif
  306 
  307         if (drv_init)
  308                 return(drv_init);
  309 
  310         drv_init = -1;
  311 
  312         bzero(&dg, sizeof(dg));
  313         dcons_conf = &dg;
  314         dg.cdev = &dcons_consdev;
  315         dg.buf = NULL;
  316         dg.size = DCONS_BUF_SIZE;
  317 
  318 #if defined(__i386__) || defined(__amd64__)
  319         if (getenv_quad("dcons.addr", &addr) > 0 &&
  320             getenv_quad("dcons.size", &size) > 0) {
  321 #ifdef __i386__
  322                 vm_paddr_t pa;
  323                 /*
  324                  * Allow read/write access to dcons buffer.
  325                  */
  326                 for (pa = trunc_page(addr); pa < addr + size; pa += PAGE_SIZE)
  327                         pmap_ksetrw(PMAP_MAP_LOW + pa);
  328                 invltlb();
  329 #endif
  330                 /* XXX P to V */
  331 #ifdef __amd64__
  332                 dg.buf = (struct dcons_buf *)(vm_offset_t)(KERNBASE + addr);
  333 #else /* __i386__ */
  334                 dg.buf = (struct dcons_buf *)(vm_offset_t)(PMAP_MAP_LOW +
  335                     addr);
  336 #endif
  337                 dg.size = size;
  338                 if (dcons_load_buffer(dg.buf, dg.size, sc) < 0)
  339                         dg.buf = NULL;
  340         }
  341 #endif
  342         if (dg.buf != NULL)
  343                 goto ok;
  344 
  345 #ifndef KLD_MODULE
  346         if (stage == 0) { /* XXX or cold */
  347                 /*
  348                  * DCONS_FORCE_CONSOLE == 1 and statically linked.
  349                  * called from cninit(). can't use contigmalloc yet .
  350                  */
  351                 dg.buf = (struct dcons_buf *) bssbuf;
  352                 dcons_init(dg.buf, dg.size, sc);
  353         } else
  354 #endif
  355         {
  356                 /*
  357                  * DCONS_FORCE_CONSOLE == 0 or kernel module case.
  358                  * if the module is loaded after boot,
  359                  * bssbuf could be non-continuous.
  360                  */ 
  361                 dg.buf = (struct dcons_buf *) contigmalloc(dg.size,
  362                         M_DEVBUF, 0, 0x10000, 0xffffffff, PAGE_SIZE, 0ul);
  363                 if (dg.buf == NULL)
  364                         return (-1);
  365                 dcons_init(dg.buf, dg.size, sc);
  366         }
  367 
  368 ok:
  369         dcons_buf = dg.buf;
  370 
  371         drv_init = 1;
  372 
  373         return 0;
  374 }
  375 
  376 
  377 static int
  378 dcons_attach_port(int port, char *name, int flags)
  379 {
  380         struct dcons_softc *dc;
  381         struct tty *tp;
  382 
  383         dc = &sc[port];
  384         tp = tty_alloc(&dcons_ttydevsw, dc);
  385         dc->flags = flags;
  386         dc->tty   = tp;
  387         tty_init_console(tp, 0);
  388         tty_makedev(tp, NULL, "%s", name);
  389         return(0);
  390 }
  391 
  392 static int
  393 dcons_attach(void)
  394 {
  395         int polltime;
  396 
  397         dcons_attach_port(DCONS_CON, "dcons", 0);
  398         dcons_attach_port(DCONS_GDB, "dgdb", DC_GDB);
  399         callout_init(&dcons_callout, 1);
  400         polltime = hz / poll_hz;
  401         callout_reset(&dcons_callout, polltime, dcons_timeout, NULL);
  402         return(0);
  403 }
  404 
  405 static int
  406 dcons_detach(int port)
  407 {
  408         struct  tty *tp;
  409         struct dcons_softc *dc;
  410 
  411         dc = &sc[port];
  412         tp = dc->tty;
  413 
  414         /* tty_rel_gone() schedules a deferred free callback, count it. */
  415         atomic_add_int(&dcons_close_refs, 1);
  416         tty_lock(tp);
  417         tty_rel_gone(tp);
  418 
  419         return(0);
  420 }
  421 
  422 static int
  423 dcons_modevent(module_t mode, int type, void *data)
  424 {
  425         int err = 0, ret;
  426 
  427         switch (type) {
  428         case MOD_LOAD:
  429                 ret = dcons_drv_init(1);
  430                 if (ret != -1)
  431                         dcons_attach();
  432                 if (ret == 0) {
  433                         dcons_cnprobe(&dcons_consdev);
  434                         dcons_cninit(&dcons_consdev);
  435                         cnadd(&dcons_consdev);
  436                 }
  437                 break;
  438         case MOD_UNLOAD:
  439                 printf("dcons: unload\n");
  440                 if (drv_init == 1) {
  441                         callout_stop(&dcons_callout);
  442                         cnremove(&dcons_consdev);
  443                         dcons_detach(DCONS_CON);
  444                         dcons_detach(DCONS_GDB);
  445                         dg.buf->magic = 0;
  446 
  447                         contigfree(dg.buf, DCONS_BUF_SIZE, M_DEVBUF);
  448                 }
  449 
  450                 /* Wait for tty deferred free callbacks to complete. */
  451                 while (atomic_load_acq_int(&dcons_close_refs) > 0)
  452                         pause_sbt("dcunld", mstosbt(50), mstosbt(10), 0);
  453                 break;
  454         case MOD_SHUTDOWN:
  455 #if 0           /* Keep connection after halt */
  456                 dg.buf->magic = 0;
  457 #endif
  458                 break;
  459         default:
  460                 err = EOPNOTSUPP;
  461                 break;
  462         }
  463         return(err);
  464 }
  465 
  466 #if defined(GDB)
  467 /* Debugger interface */
  468 
  469 static int
  470 dcons_os_getc(struct dcons_softc *dc)
  471 {
  472         int c;
  473 
  474         while ((c = dcons_os_checkc(dc)) == -1);
  475 
  476         return (c & 0xff);
  477 }
  478 
  479 static int
  480 dcons_dbg_probe(void)
  481 {
  482         int dcons_gdb;
  483 
  484         if (getenv_int("dcons_gdb", &dcons_gdb) == 0)
  485                 return (-1);
  486         return (dcons_gdb);
  487 }
  488 
  489 static void
  490 dcons_dbg_init(void)
  491 {
  492 }
  493 
  494 static void
  495 dcons_dbg_term(void)
  496 {
  497 }
  498 
  499 static void
  500 dcons_dbg_putc(int c)
  501 {
  502         struct dcons_softc *dc = &sc[DCONS_GDB];
  503         dcons_os_putc(dc, c);
  504 }
  505 
  506 static int
  507 dcons_dbg_getc(void)
  508 {
  509         struct dcons_softc *dc = &sc[DCONS_GDB];
  510         return (dcons_os_getc(dc));
  511 }
  512 #endif
  513 
  514 DEV_MODULE(dcons, dcons_modevent, NULL);
  515 MODULE_VERSION(dcons, DCONS_VERSION);
Cache object: 998f5b23c77870bd61ce77095fb5d808
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/dev/dcons/dcons_os.c

FreeBSD/Linux Kernel Cross Reference
sys/dev/dcons/dcons_os.c
