kernel/arch/x86/platform/i86pc/os/graphics.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25
  26 #include <sys/types.h>
  27 #include <sys/systm.h>
  28 #include <sys/bootconf.h>
  29 #include <sys/thread.h>
  30 #include <sys/ddi.h>
  31 #include <sys/sunddi.h>
  32 #include <vm/seg_kmem.h>
  33 #include <sys/file.h>
  34 #include <sys/kd.h>
  35 #include <sys/sunldi.h>
  36
  37 #define VIDEOMEM        0xa0000
  38
  39 extern void outb(int, uchar_t);
  40
  41 static int graphics_mode;
  42 static int cursor_y = 309;
  43 static int cursor_x = 136;
  44
  45 #define BAR_STEPS 46
  46
  47 static uchar_t bar[BAR_STEPS];
  48 static kthread_t *progressbar_tid;
  49 static kmutex_t pbar_lock;
  50 static kcondvar_t pbar_cv;
  51 static char *videomem = (caddr_t)VIDEOMEM;
  52 static int videomem_size;
  53
  54 /* select the plane(s) to draw to */
  55 static void
  56 mapmask(int plane)
  57 {
  58         outb(0x3c4, 2);
  59         outb(0x3c5, plane);
  60 }
  61
  62 static void
  63 bitmask(int value)
  64 {
  65         outb(0x3ce, 8);
  66         outb(0x3cf, value);
  67 }
  68
  69 static void
  70 progressbar_show(void)
  71 {
  72         int j, k, offset;
  73         uchar_t *mem, *ptr;
  74
  75         offset = cursor_y * 80 + cursor_x / 8;
  76         mem = (uchar_t *)videomem + offset;
  77
  78         bitmask(0xff);
  79         mapmask(0xff); /* write to all planes at once? */
  80         for (j = 0; j < 4; j++) {   /* bar height: 4 pixels */
  81                 ptr = mem + j * 80;
  82                 for (k = 0; k < BAR_STEPS; k++, ptr++)
  83                         *ptr = bar[k];
  84         }
  85         bitmask(0x00);
  86 }
  87
  88 /*
  89  * Initialize a rectangle area for progress bar
  90  *
  91  * Multiboot has initialized graphics mode to 640x480
  92  * with 16 colors.
  93  */
  94 void
  95 progressbar_init()
  96 {
  97         int i;
  98         char cons[10];
  99
 100         /* see if we are in graphics mode */
 101         if (BOP_GETPROPLEN(bootops, "console") != sizeof ("graphics"))
 102                 return;
 103         (void) BOP_GETPROP(bootops, "console", cons);
 104         if (strncmp(cons, "graphics", strlen("graphics")) != 0)
 105                 return;
 106
 107         graphics_mode = 1;
 108
 109         for (i = 0; i < BAR_STEPS; i++) {
 110                 bar[i] = 0x00;
 111         }
 112
 113         progressbar_show();
 114 }
 115
 116 static void
 117 progressbar_step()
 118 {
 119         static int limit = 0;
 120
 121         bar[limit] = 0xff;
 122
 123         if (limit > 3)
 124                 bar[limit - 4] = 0x00;
 125         else
 126                 bar[limit + BAR_STEPS - 4] = 0x00;
 127
 128         limit++;
 129         if (limit == BAR_STEPS)
 130                 limit = 0;
 131
 132         progressbar_show();
 133 }
 134
 135 /*ARGSUSED*/
 136 static void
 137 progressbar_thread(void *arg)
 138 {
 139         clock_t end = drv_usectohz(150000);
 140
 141         mutex_enter(&pbar_lock);
 142         while (graphics_mode) {
 143                 progressbar_step();
 144                 (void) cv_reltimedwait(&pbar_cv, &pbar_lock, end,
 145                     TR_CLOCK_TICK);
 146         }
 147         mutex_exit(&pbar_lock);
 148 }
 149
 150 void
 151 progressbar_start(void)
 152 {
 153 #if !defined(__xpv)
 154         extern pri_t minclsyspri;
 155
 156         if (graphics_mode == 0)
 157                 return;
 158
 159         /* map video memory to kernel heap */
 160         videomem_size = ptob(btopr(38400));     /* 640 x 480 / 8 bytes */
 161         videomem = vmem_alloc(heap_arena, videomem_size, VM_SLEEP);
 162         if (videomem == NULL) {
 163                 cmn_err(CE_NOTE, "!failed to start progress bar");
 164                 graphics_mode = 0;
 165                 return;
 166         }
 167         hat_devload(kas.a_hat, videomem, videomem_size,
 168             btop(VIDEOMEM), (PROT_READ | PROT_WRITE),
 169             HAT_LOAD_NOCONSIST | HAT_LOAD_LOCK);
 170
 171         progressbar_tid = thread_create(NULL, 0, progressbar_thread,
 172             NULL, 0, &p0, TS_RUN, minclsyspri);
 173 #endif
 174 }
 175
 176 void
 177 progressbar_stop(void)
 178 {
 179 #if !defined(__xpv)
 180         if (graphics_mode == 0)
 181                 return;
 182
 183         graphics_mode = 0;
 184         mutex_enter(&pbar_lock);
 185         cv_signal(&pbar_cv);
 186         mutex_exit(&pbar_lock);
 187         if (progressbar_tid != NULL)
 188                 thread_join(progressbar_tid->t_did);
 189
 190         /* unmap video memory */
 191         hat_unload(kas.a_hat, videomem, videomem_size, HAT_UNLOAD_UNLOCK);
 192         vmem_free(heap_arena, videomem, videomem_size);
 193 #endif
 194 }
 195
 196 /*ARGSUSED*/
 197 void
 198 progressbar_key_abort(ldi_ident_t li)
 199 {
 200 #if !defined(__xpv)
 201         char *fbpath;
 202         int ret;
 203         ldi_handle_t hdl;
 204
 205         extern char *consconfig_get_plat_fbpath(void);
 206
 207         if (graphics_mode == 0)
 208                 return;
 209
 210         fbpath = consconfig_get_plat_fbpath();
 211
 212         if (ldi_open_by_name(fbpath, FWRITE, kcred, &hdl, li) != 0) {
 213                 cmn_err(CE_NOTE, "!ldi_open_by_name failed");
 214         } else {
 215                 if (ldi_ioctl(hdl, KDSETMODE, KD_RESETTEXT, FKIOCTL,
 216                     kcred, &ret)
 217                     != 0)
 218                                 cmn_err(CE_NOTE,
 219                                     "!ldi_ioctl for KD_RESETTEXT failed");
 220                 (void) ldi_close(hdl, 0, kcred);
 221         }
 222 #endif
 223 }