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
mapmask(int plane)56 mapmask(int plane)
57 {
58 outb(0x3c4, 2);
59 outb(0x3c5, plane);
60 }
61
62 static void
bitmask(int value)63 bitmask(int value)
64 {
65 outb(0x3ce, 8);
66 outb(0x3cf, value);
67 }
68
69 static void
progressbar_show(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
progressbar_init()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
progressbar_step()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
progressbar_thread(void * arg)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
progressbar_start(void)153 progressbar_start(void)
154 {
155 #if !defined(__xpv)
156 extern pri_t minclsyspri;
157
158 if (graphics_mode == 0)
159 return;
160
161 /* map video memory to kernel heap */
162 videomem_size = ptob(btopr(38400)); /* 640 x 480 / 8 bytes */
163 videomem = vmem_alloc(heap_arena, videomem_size, VM_SLEEP);
164 if (videomem == NULL) {
165 cmn_err(CE_NOTE, "!failed to start progress bar");
166 graphics_mode = 0;
167 return;
168 }
169 hat_devload(kas.a_hat, videomem, videomem_size,
170 btop(VIDEOMEM), (PROT_READ | PROT_WRITE),
171 HAT_LOAD_NOCONSIST | HAT_LOAD_LOCK);
172
173 progressbar_tid = thread_create(NULL, 0, progressbar_thread,
174 NULL, 0, &p0, TS_RUN, minclsyspri);
175 #endif
176 }
177
178 void
progressbar_stop(void)179 progressbar_stop(void)
180 {
181 #if !defined(__xpv)
182 if (graphics_mode == 0)
183 return;
184
185 graphics_mode = 0;
186 mutex_enter(&pbar_lock);
187 cv_signal(&pbar_cv);
188 mutex_exit(&pbar_lock);
189 if (progressbar_tid != NULL)
190 thread_join(progressbar_tid->t_did);
191
192 /* unmap video memory */
193 hat_unload(kas.a_hat, videomem, videomem_size, HAT_UNLOAD_UNLOCK);
194 vmem_free(heap_arena, videomem, videomem_size);
195 #endif
196 }
197
198 /*ARGSUSED*/
199 void
progressbar_key_abort(ldi_ident_t li)200 progressbar_key_abort(ldi_ident_t li)
201 {
202 #if !defined(__xpv)
203 char *fbpath;
204 int ret;
205 ldi_handle_t hdl;
206
207 extern char *consconfig_get_plat_fbpath(void);
208
209 if (graphics_mode == 0)
210 return;
211
212 fbpath = consconfig_get_plat_fbpath();
213
214 if (ldi_open_by_name(fbpath, FWRITE, kcred, &hdl, li) != 0) {
215 cmn_err(CE_NOTE, "!ldi_open_by_name failed");
216 } else {
217 if (ldi_ioctl(hdl, KDSETMODE, KD_RESETTEXT, FKIOCTL,
218 kcred, &ret)
219 != 0)
220 cmn_err(CE_NOTE,
221 "!ldi_ioctl for KD_RESETTEXT failed");
222 (void) ldi_close(hdl, 0, kcred);
223 }
224 #endif
225 }
226