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