arch/x86/kernel/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         if (BOP_GETPROPLEN(bootops, "efi-systab") > 0)
 107                 return;
 108
 109         graphics_mode = 1;
 110
 111         for (i = 0; i < BAR_STEPS; i++) {
 112                 bar[i] = 0x00;
 113         }
 114
 115         progressbar_show();
 116 }
 117
 118 static void
 119 progressbar_step()
 120 {
 121         static int limit = 0;
 122
 123         bar[limit] = 0xff;
 124
 125         if (limit > 3)
 126                 bar[limit - 4] = 0x00;
 127         else
 128                 bar[limit + BAR_STEPS - 4] = 0x00;
 129
 130         limit++;
 131         if (limit == BAR_STEPS)
 132                 limit = 0;
 133
 134         progressbar_show();
 135 }
 136
 137 /*ARGSUSED*/
 138 static void
 139 progressbar_thread(void *arg)
 140 {
 141         clock_t end = drv_usectohz(150000);
 142
 143         mutex_enter(&pbar_lock);
 144         while (graphics_mode) {
 145                 progressbar_step();
 146                 (void) cv_reltimedwait(&pbar_cv, &pbar_lock, end,
 147                     TR_CLOCK_TICK);
 148         }
 149         mutex_exit(&pbar_lock);
 150 }
 151
 152 void
 153 progressbar_start(void)
 154 {
 155         extern pri_t minclsyspri;
 156
 157         if (graphics_mode == 0)
 158                 return;
 159
 160         /* map video memory to kernel heap */
 161         videomem_size = ptob(btopr(38400));     /* 640 x 480 / 8 bytes */
 162         videomem = vmem_alloc(heap_arena, videomem_size, VM_SLEEP);
 163         if (videomem == NULL) {
 164                 cmn_err(CE_NOTE, "!failed to start progress bar");
 165                 graphics_mode = 0;
 166                 return;
 167         }
 168         hat_devload(kas.a_hat, videomem, videomem_size,
 169             btop(VIDEOMEM), (PROT_READ | PROT_WRITE),
 170             HAT_LOAD_NOCONSIST | HAT_LOAD_LOCK);
 171
 172         progressbar_tid = thread_create(NULL, 0, progressbar_thread,
 173             NULL, 0, &p0, TS_RUN, minclsyspri);
 174 }
 175
 176 void
 177 progressbar_stop(void)
 178 {
 179         if (graphics_mode == 0)
 180                 return;
 181
 182         graphics_mode = 0;
 183         mutex_enter(&pbar_lock);
 184         cv_signal(&pbar_cv);
 185         mutex_exit(&pbar_lock);
 186         if (progressbar_tid != NULL)
 187                 thread_join(progressbar_tid->t_did);
 188
 189         /* unmap video memory */
 190         hat_unload(kas.a_hat, videomem, videomem_size, HAT_UNLOAD_UNLOCK);
 191         vmem_free(heap_arena, videomem, videomem_size);
 192 }
 193
 194 /*ARGSUSED*/
 195 void
 196 progressbar_key_abort(ldi_ident_t li)
 197 {
 198         char *fbpath;
 199         int ret;
 200         ldi_handle_t hdl;
 201
 202         extern char *consconfig_get_plat_fbpath(void);
 203
 204         if (graphics_mode == 0)
 205                 return;
 206
 207         fbpath = consconfig_get_plat_fbpath();
 208
 209         if (ldi_open_by_name(fbpath, FWRITE, kcred, &hdl, li) != 0) {
 210                 cmn_err(CE_NOTE, "!ldi_open_by_name failed");
 211         } else {
 212                 if (ldi_ioctl(hdl, KDSETMODE, KD_RESETTEXT, FKIOCTL,
 213                     kcred, &ret)
 214                     != 0)
 215                                 cmn_err(CE_NOTE,
 216                                     "!ldi_ioctl for KD_RESETTEXT failed");
 217                 (void) ldi_close(hdl, 0, kcred);
 218         }
 219 }