sys/dev/syscons/snake/snake_saver.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-3-Clause
   3  *
   4  * Copyright (c) 1995-1998 Søren Schmidt
   5  * 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  *    without modification, immediately at the beginning of the file.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. The name of the author may not be used to endorse or promote products
  17  *    derived from this software without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  20  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  21  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  22  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  23  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  24  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  28  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  *
  30  * $FreeBSD$
  31  */
  32
  33 #include <sys/param.h>
  34 #include <sys/systm.h>
  35 #include <sys/module.h>
  36 #include <sys/malloc.h>
  37 #include <sys/kernel.h>
  38 #include <sys/sysctl.h>
  39 #include <sys/consio.h>
  40 #include <sys/fbio.h>
  41 #include <sys/resourcevar.h>
  42 #include <sys/smp.h>
  43
  44 #include <machine/pc/display.h>
  45
  46 #include <dev/fb/fbreg.h>
  47 #include <dev/fb/splashreg.h>
  48 #include <dev/syscons/syscons.h>
  49
  50 static u_char   *message;
  51 static int      *messagep;
  52 static int      messagelen;
  53 static int      blanked;
  54
  55 #define MSGBUF_LEN      70
  56
  57 static int      nofancy = 0;
  58 TUNABLE_INT("hw.syscons.saver_snake_nofancy", &nofancy);
  59
  60 #define FANCY_SNAKE     (!nofancy)
  61 #define LOAD_HIGH(ld)   (((ld * 100 + FSCALE / 2) >> FSHIFT) / 100)
  62 #define LOAD_LOW(ld)    (((ld * 100 + FSCALE / 2) >> FSHIFT) % 100)
  63
  64 static inline void update_msg(void);
  65
  66 static int
  67 snake_saver(video_adapter_t *adp, int blank)
  68 {
  69         static int      dirx, diry;
  70         int             f, color, load;
  71         sc_softc_t      *sc;
  72         scr_stat        *scp;
  73
  74 /* XXX hack for minimal changes. */
  75 #define save    message
  76 #define savs    messagep
  77
  78         sc = sc_find_softc(adp, NULL);
  79         if (sc == NULL)
  80                 return EAGAIN;
  81         scp = sc->cur_scp;
  82
  83         if (blank) {
  84                 if (adp->va_info.vi_flags & V_INFO_GRAPHICS)
  85                         return EAGAIN;
  86                 if (blanked <= 0) {
  87                         sc_vtb_clear(&scp->scr, sc->scr_map[0x20],
  88                                      (FG_LIGHTGREY | BG_BLACK) << 8);
  89                         vidd_set_hw_cursor(adp, -1, -1);
  90                         sc_set_border(scp, 0);
  91                         dirx = (scp->xpos ? 1 : -1);
  92                         diry = (scp->ypos ?
  93                                 scp->xsize : -scp->xsize);
  94                         for (f=0; f< messagelen; f++)
  95                                 savs[f] = scp->xpos + scp->ypos*scp->xsize;
  96                         sc_vtb_putc(&scp->scr, savs[0], sc->scr_map[*save],
  97                                     (FG_LIGHTGREY | BG_BLACK) << 8);
  98                         blanked = 1;
  99                 }
 100                 if (blanked++ < 4)
 101                         return 0;
 102                 blanked = 1;
 103                 sc_vtb_putc(&scp->scr, savs[messagelen - 1], sc->scr_map[0x20],
 104                             (FG_LIGHTGREY | BG_BLACK) << 8);
 105                 for (f=messagelen-1; f > 0; f--)
 106                         savs[f] = savs[f-1];
 107                 f = savs[0];
 108                 if ((f % scp->xsize) == 0 ||
 109                     (f % scp->xsize) == scp->xsize - 1 ||
 110                     (random() % 50) == 0)
 111                         dirx = -dirx;
 112                 if ((f / scp->xsize) == 0 ||
 113                     (f / scp->xsize) == scp->ysize - 1 ||
 114                     (random() % 20) == 0)
 115                         diry = -diry;
 116                 savs[0] += dirx + diry;
 117                 if (FANCY_SNAKE) {
 118                         update_msg();
 119                         load = ((averunnable.ldavg[0] * 100 + FSCALE / 2) >> FSHIFT);
 120                         if (load == 0)
 121                                 color = FG_LIGHTGREY | BG_BLACK;
 122                         else if (load / mp_ncpus <= 50)
 123                                 color = FG_LIGHTGREEN | BG_BLACK;
 124                         else if (load / mp_ncpus <= 75)
 125                                 color = FG_YELLOW | BG_BLACK;
 126                         else if (load / mp_ncpus <= 99)
 127                                 color = FG_LIGHTRED | BG_BLACK;
 128                         else
 129                                 color = FG_RED | FG_BLINK | BG_BLACK;
 130                 } else
 131                         color = FG_LIGHTGREY | BG_BLACK;
 132
 133                 for (f=messagelen-1; f>=0; f--)
 134                         sc_vtb_putc(&scp->scr, savs[f], sc->scr_map[save[f]],
 135                                     color << 8);
 136         } else
 137                 blanked = 0;
 138
 139         return 0;
 140 }
 141
 142 static inline void
 143 update_msg(void)
 144 {
 145         if (!FANCY_SNAKE) {
 146                 messagelen = sprintf(message, "%s %s", ostype, osrelease);
 147                 return;
 148         }
 149         messagelen = snprintf(message, MSGBUF_LEN,
 150             "%s %s (%d.%02d %d.%02d, %d.%02d)",
 151             ostype, osrelease,
 152             LOAD_HIGH(averunnable.ldavg[0]), LOAD_LOW(averunnable.ldavg[0]),
 153             LOAD_HIGH(averunnable.ldavg[1]), LOAD_LOW(averunnable.ldavg[1]),
 154             LOAD_HIGH(averunnable.ldavg[2]), LOAD_LOW(averunnable.ldavg[2]));
 155 }
 156
 157 static int
 158 snake_init(video_adapter_t *adp)
 159 {
 160         message = malloc(MSGBUF_LEN, M_DEVBUF, M_WAITOK);
 161         messagep = malloc(MSGBUF_LEN * sizeof *messagep, M_DEVBUF, M_WAITOK);
 162         update_msg();
 163         return 0;
 164 }
 165
 166 static int
 167 snake_term(video_adapter_t *adp)
 168 {
 169         free(message, M_DEVBUF);
 170         free(messagep, M_DEVBUF);
 171         return 0;
 172 }
 173
 174 static scrn_saver_t snake_module = {
 175         "snake_saver", snake_init, snake_term, snake_saver, NULL,
 176 };
 177
 178 SAVER_MODULE(snake_saver, snake_module);