]> git.saurik.com Git - apple/xnu.git/blob - osfmk/console/video_console.c
projects / apple / xnu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
xnu-4903.241.1.tar.gz
[apple/xnu.git] / osfmk / console / video_console.c
1 /*
2 * Copyright (c) 2000-2009 Apple Inc. All rights reserved.
3 *
4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
5 *
6 * This file contains Original Code and/or Modifications of Original Code
7 * as defined in and that are subject to the Apple Public Source License
8 * Version 2.0 (the 'License'). You may not use this file except in
9 * compliance with the License. The rights granted to you under the License
10 * may not be used to create, or enable the creation or redistribution of,
11 * unlawful or unlicensed copies of an Apple operating system, or to
12 * circumvent, violate, or enable the circumvention or violation of, any
13 * terms of an Apple operating system software license agreement.
14 *
15 * Please obtain a copy of the License at
16 * http://www.opensource.apple.com/apsl/ and read it before using this file.
17 *
18 * The Original Code and all software distributed under the License are
19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
23 * Please see the License for the specific language governing rights and
24 * limitations under the License.
25 *
26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
27 */
28 /*
29 * @OSF_FREE_COPYRIGHT@
30 *
31 */
32 /*
33 * @APPLE_FREE_COPYRIGHT@
34 */
35 /*
36 * NetBSD: ite.c,v 1.16 1995/07/17 01:24:34 briggs Exp
37 *
38 * Copyright (c) 1988 University of Utah.
39 * Copyright (c) 1990, 1993
40 * The Regents of the University of California. All rights reserved.
41 *
42 * This code is derived from software contributed to Berkeley by
43 * the Systems Programming Group of the University of Utah Computer
44 * Science Department.
45 *
46 * Redistribution and use in source and binary forms, with or without
47 * modification, are permitted provided that the following conditions
48 * are met:
49 * 1. Redistributions of source code must retain the above copyright
50 * notice, this list of conditions and the following disclaimer.
51 * 2. Redistributions in binary form must reproduce the above copyright
52 * notice, this list of conditions and the following disclaimer in the
53 * documentation and/or other materials provided with the distribution.
54 * 3. All advertising materials mentioning features or use of this software
55 * must display the following acknowledgement:
56 * This product includes software developed by the University of
57 * California, Berkeley and its contributors.
58 * 4. Neither the name of the University nor the names of its contributors
59 * may be used to endorse or promote products derived from this software
60 * without specific prior written permission.
61 *
62 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
63 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
64 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
65 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
66 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
67 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
68 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
69 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
70 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
71 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
72 * SUCH DAMAGE.
73 *
74 * from: Utah $Hdr: ite.c 1.28 92/12/20$
75 *
76 * @(#)ite.c 8.2 (Berkeley) 1/12/94
77 */
78
79 /*
80 * ite.c
81 *
82 * The ite module handles the system console; that is, stuff printed
83 * by the kernel and by user programs while "desktop" and X aren't
84 * running. Some (very small) parts are based on hp300's 4.4 ite.c,
85 * hence the above copyright.
86 *
87 * -- Brad and Lawrence, June 26th, 1994
88 *
89 */
90
91 #include <console/video_console.h>
92 #include <console/serial_protos.h>
93
94 #include <kern/kern_types.h>
95 #include <kern/kalloc.h>
96 #include <kern/debug.h>
97 #include <kern/spl.h>
98 #include <kern/thread_call.h>
99
100 #include <vm/pmap.h>
101 #include <vm/vm_kern.h>
102 #include <machine/io_map_entries.h>
103 #include <machine/machine_cpu.h>
104
105 #include <pexpert/pexpert.h>
106 #include <sys/kdebug.h>
107
108 #include "iso_font.c"
109 #if !CONFIG_EMBEDDED
110 #include "progress_meter_data.c"
111 #endif
112
113 #include "sys/msgbuf.h"
114
115 /*
116 * Generic Console (Front-End)
117 * ---------------------------
118 */
119
120 struct vc_info vinfo;
121
122 void noroot_icon_test(void);
123
124
125 extern int disableConsoleOutput;
126 static boolean_t gc_enabled = FALSE;
127 static boolean_t gc_initialized = FALSE;
128 static boolean_t vm_initialized = FALSE;
129
130 static struct {
131 void (*initialize)(struct vc_info * info);
132 void (*enable)(boolean_t enable);
133 void (*paint_char)(unsigned int xx, unsigned int yy, unsigned char ch,
134 int attrs, unsigned char ch_previous,
135 int attrs_previous);
136 void (*clear_screen)(unsigned int xx, unsigned int yy, unsigned int top,
137 unsigned int bottom, int which);
138 void (*scroll_down)(int num, unsigned int top, unsigned int bottom);
139 void (*scroll_up)(int num, unsigned int top, unsigned int bottom);
140 void (*hide_cursor)(unsigned int xx, unsigned int yy);
141 void (*show_cursor)(unsigned int xx, unsigned int yy);
142 void (*update_color)(int color, boolean_t fore);
143 } gc_ops;
144
145 static unsigned char *gc_buffer_attributes;
146 static unsigned char *gc_buffer_characters;
147 static unsigned char *gc_buffer_colorcodes;
148 static unsigned char *gc_buffer_tab_stops;
149 static uint32_t gc_buffer_columns;
150 static uint32_t gc_buffer_rows;
151 static uint32_t gc_buffer_size;
152
153 #if defined(__i386__) || defined(__x86_64__)
154 decl_simple_lock_data(static, vcputc_lock);
155
156 #define VCPUTC_LOCK_INIT() \
157 MACRO_BEGIN \
158 simple_lock_init(&vcputc_lock, 0); \
159 MACRO_END
160
161 #define VCPUTC_LOCK_LOCK() \
162 MACRO_BEGIN \
163 boolean_t istate = ml_get_interrupts_enabled(); \
164 while (!simple_lock_try(&vcputc_lock)) \
165 { \
166 if (!istate) \
167 handle_pending_TLB_flushes(); \
168 cpu_pause(); \
169 } \
170 MACRO_END
171
172 #define VCPUTC_LOCK_UNLOCK() \
173 MACRO_BEGIN \
174 simple_unlock(&vcputc_lock); \
175 MACRO_END
176 #else
177 static hw_lock_data_t vcputc_lock;
178
179 #define VCPUTC_LOCK_INIT() \
180 MACRO_BEGIN \
181 hw_lock_init(&vcputc_lock); \
182 MACRO_END
183
184 #define VCPUTC_LOCK_LOCK() \
185 MACRO_BEGIN \
186 if (!hw_lock_to(&vcputc_lock, ~0U))\
187 { \
188 panic("VCPUTC_LOCK_LOCK"); \
189 } \
190 MACRO_END
191
192 #define VCPUTC_LOCK_UNLOCK() \
193 MACRO_BEGIN \
194 hw_lock_unlock(&vcputc_lock); \
195 MACRO_END
196 #endif
197
198 /*
199 # Attribute codes:
200 # 00=none 01=bold 04=underscore 05=blink 07=reverse 08=concealed
201 # Text color codes:
202 # 30=black 31=red 32=green 33=yellow 34=blue 35=magenta 36=cyan 37=white
203 # Background color codes:
204 # 40=black 41=red 42=green 43=yellow 44=blue 45=magenta 46=cyan 47=white
205 */
206
207 #define ATTR_NONE 0
208 #define ATTR_BOLD 1
209 #define ATTR_UNDER 2
210 #define ATTR_REVERSE 4
211
212 #define COLOR_BACKGROUND 0
213 #define COLOR_FOREGROUND 7
214
215 #define COLOR_CODE_GET(code, fore) (((code) & ((fore) ? 0xF0 : 0x0F)) >> ((fore) ? 4 : 0))
216 #define COLOR_CODE_SET(code, color, fore) (((code) & ((fore) ? 0x0F : 0xF0)) | ((color) << ((fore) ? 4 : 0)))
217
218 static unsigned char gc_color_code;
219
220 /* VT100 state: */
221 #define MAXPARS 16
222 static unsigned int gc_x, gc_y, gc_savex, gc_savey;
223 static unsigned int gc_par[MAXPARS], gc_numpars, gc_hanging_cursor, gc_attr, gc_saveattr;
224
225 /* VT100 scroll region */
226 static unsigned int gc_scrreg_top, gc_scrreg_bottom;
227
228 enum vt100state_e {
229 ESnormal, /* Nothing yet */
230 ESesc, /* Got ESC */
231 ESsquare, /* Got ESC [ */
232 ESgetpars, /* About to get or getting the parameters */
233 ESgotpars, /* Finished getting the parameters */
234 ESfunckey, /* Function key */
235 EShash, /* DEC-specific stuff (screen align, etc.) */
236 ESsetG0, /* Specify the G0 character set */
237 ESsetG1, /* Specify the G1 character set */
238 ESask,
239 EScharsize,
240 ESignore /* Ignore this sequence */
241 } gc_vt100state = ESnormal;
242
243
244 enum
245 {
246 /* secs */
247 kProgressAcquireDelay = 0,
248 #if CONFIG_EMBEDDED
249 kProgressReacquireDelay = 5,
250 #else
251 kProgressReacquireDelay = 5,
252 #endif
253 };
254
255 static int8_t vc_rotate_matr[4][2][2] = {
256 { { 1, 0 },
257 { 0, 1 } },
258 { { 0, 1 },
259 { -1, 0 } },
260 { { -1, 0 },
261 { 0, -1 } },
262 { { 0, -1 },
263 { 1, 0 } }
264 };
265
266 static int gc_wrap_mode = 1, gc_relative_origin = 0;
267 static int gc_charset_select = 0, gc_save_charset_s = 0;
268 static int gc_charset[2] = { 0, 0 };
269 static int gc_charset_save[2] = { 0, 0 };
270
271 static void gc_clear_line(unsigned int xx, unsigned int yy, int which);
272 static void gc_clear_screen(unsigned int xx, unsigned int yy, int top,
273 unsigned int bottom, int which);
274 static void gc_enable(boolean_t enable);
275 static void gc_hide_cursor(unsigned int xx, unsigned int yy);
276 static void gc_initialize(struct vc_info * info);
277 static boolean_t gc_is_tab_stop(unsigned int column);
278 static void gc_paint_char(unsigned int xx, unsigned int yy, unsigned char ch,
279 int attrs);
280 static void gc_putchar(char ch);
281 static void gc_putc_askcmd(unsigned char ch);
282 static void gc_putc_charsetcmd(int charset, unsigned char ch);
283 static void gc_putc_charsizecmd(unsigned char ch);
284 static void gc_putc_esc(unsigned char ch);
285 static void gc_putc_getpars(unsigned char ch);
286 static void gc_putc_gotpars(unsigned char ch);
287 static void gc_putc_normal(unsigned char ch);
288 static void gc_putc_square(unsigned char ch);
289 static void gc_reset_screen(void);
290 static void gc_reset_tabs(void);
291 static void gc_reset_vt100(void);
292 static void gc_scroll_down(int num, unsigned int top, unsigned int bottom);
293 static void gc_scroll_up(int num, unsigned int top, unsigned int bottom);
294 static void gc_set_tab_stop(unsigned int column, boolean_t enabled);
295 static void gc_show_cursor(unsigned int xx, unsigned int yy);
296 static void gc_update_color(int color, boolean_t fore);
297
298 static void
299 gc_clear_line(unsigned int xx, unsigned int yy, int which)
300 {
301 unsigned int start, end, i;
302
303 /*
304 * This routine runs extremely slowly. I don't think it's
305 * used all that often, except for To end of line. I'll go
306 * back and speed this up when I speed up the whole vc
307 * module. --LK
308 */
309
310 switch (which) {
311 case 0: /* To end of line */
312 start = xx;
313 end = vinfo.v_columns-1;
314 break;
315 case 1: /* To start of line */
316 start = 0;
317 end = xx;
318 break;
319 case 2: /* Whole line */
320 start = 0;
321 end = vinfo.v_columns-1;
322 break;
323 default:
324 return;
325 }
326
327 for (i = start; i <= end; i++) {
328 gc_paint_char(i, yy, ' ', ATTR_NONE);
329 }
330 }
331
332 static void
333 gc_clear_screen(unsigned int xx, unsigned int yy, int top, unsigned int bottom,
334 int which)
335 {
336 if (!gc_buffer_size) return;
337
338 if ( xx < gc_buffer_columns && yy < gc_buffer_rows && bottom <= gc_buffer_rows )
339 {
340 uint32_t start, end;
341
342 switch (which) {
343 case 0: /* To end of screen */
344 start = (yy * gc_buffer_columns) + xx;
345 end = (bottom * gc_buffer_columns) - 1;
346 break;
347 case 1: /* To start of screen */
348 start = (top * gc_buffer_columns);
349 end = (yy * gc_buffer_columns) + xx;
350 break;
351 case 2: /* Whole screen */
352 start = (top * gc_buffer_columns);
353 end = (bottom * gc_buffer_columns) - 1;
354 break;
355 default:
356 start = 0;
357 end = 0;
358 break;
359 }
360
361 memset(gc_buffer_attributes + start, ATTR_NONE, end - start + 1);
362 memset(gc_buffer_characters + start, ' ', end - start + 1);
363 memset(gc_buffer_colorcodes + start, gc_color_code, end - start + 1);
364 }
365
366 gc_ops.clear_screen(xx, yy, top, bottom, which);
367 }
368
369 static void
370 gc_enable( boolean_t enable )
371 {
372 unsigned char *buffer_attributes = NULL;
373 unsigned char *buffer_characters = NULL;
374 unsigned char *buffer_colorcodes = NULL;
375 unsigned char *buffer_tab_stops = NULL;
376 uint32_t buffer_columns = 0;
377 uint32_t buffer_rows = 0;
378 uint32_t buffer_size = 0;
379 spl_t s;
380
381 if ( enable == FALSE )
382 {
383 // only disable console output if it goes to the graphics console
384 if ( console_is_serial() == FALSE )
385 disableConsoleOutput = TRUE;
386 gc_enabled = FALSE;
387 gc_ops.enable(FALSE);
388 }
389
390 s = splhigh( );
391 VCPUTC_LOCK_LOCK( );
392
393 if ( gc_buffer_size )
394 {
395 buffer_attributes = gc_buffer_attributes;
396 buffer_characters = gc_buffer_characters;
397 buffer_colorcodes = gc_buffer_colorcodes;
398 buffer_tab_stops = gc_buffer_tab_stops;
399 buffer_columns = gc_buffer_columns;
400 buffer_rows = gc_buffer_rows;
401 buffer_size = gc_buffer_size;
402
403 gc_buffer_attributes = NULL;
404 gc_buffer_characters = NULL;
405 gc_buffer_colorcodes = NULL;
406 gc_buffer_tab_stops = NULL;
407 gc_buffer_columns = 0;
408 gc_buffer_rows = 0;
409 gc_buffer_size = 0;
410
411 VCPUTC_LOCK_UNLOCK( );
412 splx( s );
413
414 kfree( buffer_attributes, buffer_size );
415 kfree( buffer_characters, buffer_size );
416 kfree( buffer_colorcodes, buffer_size );
417 kfree( buffer_tab_stops, buffer_columns );
418 }
419 else
420 {
421 VCPUTC_LOCK_UNLOCK( );
422 splx( s );
423 }
424
425 if ( enable )
426 {
427 if ( vm_initialized )
428 {
429 buffer_columns = vinfo.v_columns;
430 buffer_rows = vinfo.v_rows;
431 buffer_size = buffer_columns * buffer_rows;
432
433 if ( buffer_size )
434 {
435 buffer_attributes = (unsigned char *) kalloc( buffer_size );
436 buffer_characters = (unsigned char *) kalloc( buffer_size );
437 buffer_colorcodes = (unsigned char *) kalloc( buffer_size );
438 buffer_tab_stops = (unsigned char *) kalloc( buffer_columns );
439
440 if ( buffer_attributes == NULL ||
441 buffer_characters == NULL ||
442 buffer_colorcodes == NULL ||
443 buffer_tab_stops == NULL )
444 {
445 if ( buffer_attributes ) kfree( buffer_attributes, buffer_size );
446 if ( buffer_characters ) kfree( buffer_characters, buffer_size );
447 if ( buffer_colorcodes ) kfree( buffer_colorcodes, buffer_size );
448 if ( buffer_tab_stops ) kfree( buffer_tab_stops, buffer_columns );
449
450 buffer_attributes = NULL;
451 buffer_characters = NULL;
452 buffer_colorcodes = NULL;
453 buffer_tab_stops = NULL;
454 buffer_columns = 0;
455 buffer_rows = 0;
456 buffer_size = 0;
457 }
458 else
459 {
460 memset( buffer_attributes, ATTR_NONE, buffer_size );
461 memset( buffer_characters, ' ', buffer_size );
462 memset( buffer_colorcodes, COLOR_CODE_SET( 0, COLOR_FOREGROUND, TRUE ), buffer_size );
463 memset( buffer_tab_stops, 0, buffer_columns );
464 }
465 }
466 }
467
468 s = splhigh( );
469 VCPUTC_LOCK_LOCK( );
470
471 gc_buffer_attributes = buffer_attributes;
472 gc_buffer_characters = buffer_characters;
473 gc_buffer_colorcodes = buffer_colorcodes;
474 gc_buffer_tab_stops = buffer_tab_stops;
475 gc_buffer_columns = buffer_columns;
476 gc_buffer_rows = buffer_rows;
477 gc_buffer_size = buffer_size;
478
479 gc_reset_screen();
480
481 VCPUTC_LOCK_UNLOCK( );
482 splx( s );
483
484 gc_ops.clear_screen(gc_x, gc_y, 0, vinfo.v_rows, 2);
485 gc_ops.show_cursor(gc_x, gc_y);
486
487 gc_ops.enable(TRUE);
488 gc_enabled = TRUE;
489 disableConsoleOutput = FALSE;
490 }
491 }
492
493 static void
494 gc_hide_cursor(unsigned int xx, unsigned int yy)
495 {
496 if ( xx < gc_buffer_columns && yy < gc_buffer_rows )
497 {
498 uint32_t index = (yy * gc_buffer_columns) + xx;
499 unsigned char attribute = gc_buffer_attributes[index];
500 unsigned char character = gc_buffer_characters[index];
501 unsigned char colorcode = gc_buffer_colorcodes[index];
502 unsigned char colorcodesave = gc_color_code;
503
504 gc_update_color(COLOR_CODE_GET(colorcode, TRUE ), TRUE );
505 gc_update_color(COLOR_CODE_GET(colorcode, FALSE), FALSE);
506
507 gc_ops.paint_char(xx, yy, character, attribute, 0, 0);
508
509 gc_update_color(COLOR_CODE_GET(colorcodesave, TRUE ), TRUE );
510 gc_update_color(COLOR_CODE_GET(colorcodesave, FALSE), FALSE);
511 }
512 else
513 {
514 gc_ops.hide_cursor(xx, yy);
515 }
516 }
517
518 static void
519 gc_initialize(struct vc_info * info)
520 {
521 if ( gc_initialized == FALSE )
522 {
523 /* Init our lock */
524 VCPUTC_LOCK_INIT();
525
526 gc_initialized = TRUE;
527 }
528
529 gc_ops.initialize(info);
530
531 gc_reset_vt100();
532 gc_x = gc_y = 0;
533 }
534
535 static void
536 gc_paint_char(unsigned int xx, unsigned int yy, unsigned char ch, int attrs)
537 {
538 if ( xx < gc_buffer_columns && yy < gc_buffer_rows )
539 {
540 uint32_t index = (yy * gc_buffer_columns) + xx;
541
542 gc_buffer_attributes[index] = attrs;
543 gc_buffer_characters[index] = ch;
544 gc_buffer_colorcodes[index] = gc_color_code;
545 }
546
547 gc_ops.paint_char(xx, yy, ch, attrs, 0, 0);
548 }
549
550 static void
551 gc_putchar(char ch)
552 {
553 if (!ch) {
554 return; /* ignore null characters */
555 }
556 switch (gc_vt100state) {
557 default:gc_vt100state = ESnormal; /* FALLTHROUGH */
558 case ESnormal:
559 gc_putc_normal(ch);
560 break;
561 case ESesc:
562 gc_putc_esc(ch);
563 break;
564 case ESsquare:
565 gc_putc_square(ch);
566 break;
567 case ESgetpars:
568 gc_putc_getpars(ch);
569 break;
570 case ESgotpars:
571 gc_putc_gotpars(ch);
572 break;
573 case ESask:
574 gc_putc_askcmd(ch);
575 break;
576 case EScharsize:
577 gc_putc_charsizecmd(ch);
578 break;
579 case ESsetG0:
580 gc_putc_charsetcmd(0, ch);
581 break;
582 case ESsetG1:
583 gc_putc_charsetcmd(1, ch);
584 break;
585 }
586
587 if (gc_x >= vinfo.v_columns) {
588 if (0 == vinfo.v_columns)
589 gc_x = 0;
590 else
591 gc_x = vinfo.v_columns - 1;
592 }
593 if (gc_y >= vinfo.v_rows) {
594 if (0 == vinfo.v_rows)
595 gc_y = 0;
596 else
597 gc_y = vinfo.v_rows - 1;
598 }
599 }
600
601 static void
602 gc_putc_askcmd(unsigned char ch)
603 {
604 if (ch >= '0' && ch <= '9') {
605 gc_par[gc_numpars] = (10*gc_par[gc_numpars]) + (ch-'0');
606 return;
607 }
608 gc_vt100state = ESnormal;
609
610 switch (gc_par[0]) {
611 case 6:
612 gc_relative_origin = ch == 'h';
613 break;
614 case 7: /* wrap around mode h=1, l=0*/
615 gc_wrap_mode = ch == 'h';
616 break;
617 default:
618 break;
619 }
620
621 }
622
623 static void
624 gc_putc_charsetcmd(int charset, unsigned char ch)
625 {
626 gc_vt100state = ESnormal;
627
628 switch (ch) {
629 case 'A' :
630 case 'B' :
631 default:
632 gc_charset[charset] = 0;
633 break;
634 case '0' : /* Graphic characters */
635 case '2' :
636 gc_charset[charset] = 0x21;
637 break;
638 }
639
640 }
641
642 static void
643 gc_putc_charsizecmd(unsigned char ch)
644 {
645 gc_vt100state = ESnormal;
646
647 switch (ch) {
648 case '3' :
649 case '4' :
650 case '5' :
651 case '6' :
652 break;
653 case '8' : /* fill 'E's */
654 {
655 unsigned int xx, yy;
656 for (yy = 0; yy < vinfo.v_rows; yy++)
657 for (xx = 0; xx < vinfo.v_columns; xx++)
658 gc_paint_char(xx, yy, 'E', ATTR_NONE);
659 }
660 break;
661 }
662
663 }
664
665 static void
666 gc_putc_esc(unsigned char ch)
667 {
668 gc_vt100state = ESnormal;
669
670 switch (ch) {
671 case '[':
672 gc_vt100state = ESsquare;
673 break;
674 case 'c': /* Reset terminal */
675 gc_reset_vt100();
676 gc_clear_screen(gc_x, gc_y, 0, vinfo.v_rows, 2);
677 gc_x = gc_y = 0;
678 break;
679 case 'D': /* Line feed */
680 case 'E':
681 if (gc_y >= gc_scrreg_bottom -1) {
682 gc_scroll_up(1, gc_scrreg_top, gc_scrreg_bottom);
683 gc_y = gc_scrreg_bottom - 1;
684 } else {
685 gc_y++;
686 }
687 if (ch == 'E') gc_x = 0;
688 break;
689 case 'H': /* Set tab stop */
690 gc_set_tab_stop(gc_x, TRUE);
691 break;
692 case 'M': /* Cursor up */
693 if (gc_y <= gc_scrreg_top) {
694 gc_scroll_down(1, gc_scrreg_top, gc_scrreg_bottom);
695 gc_y = gc_scrreg_top;
696 } else {
697 gc_y--;
698 }
699 break;
700 case '>':
701 gc_reset_vt100();
702 break;
703 case '7': /* Save cursor */
704 gc_savex = gc_x;
705 gc_savey = gc_y;
706 gc_saveattr = gc_attr;
707 gc_save_charset_s = gc_charset_select;
708 gc_charset_save[0] = gc_charset[0];
709 gc_charset_save[1] = gc_charset[1];
710 break;
711 case '8': /* Restore cursor */
712 gc_x = gc_savex;
713 gc_y = gc_savey;
714 gc_attr = gc_saveattr;
715 gc_charset_select = gc_save_charset_s;
716 gc_charset[0] = gc_charset_save[0];
717 gc_charset[1] = gc_charset_save[1];
718 break;
719 case 'Z': /* return terminal ID */
720 break;
721 case '#': /* change characters height */
722 gc_vt100state = EScharsize;
723 break;
724 case '(':
725 gc_vt100state = ESsetG0;
726 break;
727 case ')': /* character set sequence */
728 gc_vt100state = ESsetG1;
729 break;
730 case '=':
731 break;
732 default:
733 /* Rest not supported */
734 break;
735 }
736
737 }
738
739 static void
740 gc_putc_getpars(unsigned char ch)
741 {
742 if (ch == '?') {
743 gc_vt100state = ESask;
744 return;
745 }
746 if (ch == '[') {
747 gc_vt100state = ESnormal;
748 /* Not supported */
749 return;
750 }
751 if (ch == ';' && gc_numpars < MAXPARS - 1) {
752 gc_numpars++;
753 } else
754 if (ch >= '0' && ch <= '9') {
755 gc_par[gc_numpars] *= 10;
756 gc_par[gc_numpars] += ch - '0';
757 } else {
758 gc_numpars++;
759 gc_vt100state = ESgotpars;
760 gc_putc_gotpars(ch);
761 }
762 }
763
764 static void
765 gc_putc_gotpars(unsigned char ch)
766 {
767 unsigned int i;
768
769 if (ch < ' ') {
770 /* special case for vttest for handling cursor
771 movement in escape sequences */
772 gc_putc_normal(ch);
773 gc_vt100state = ESgotpars;
774 return;
775 }
776 gc_vt100state = ESnormal;
777 switch (ch) {
778 case 'A': /* Up */
779 gc_y -= gc_par[0] ? gc_par[0] : 1;
780 if (gc_y < gc_scrreg_top)
781 gc_y = gc_scrreg_top;
782 break;
783 case 'B': /* Down */
784 gc_y += gc_par[0] ? gc_par[0] : 1;
785 if (gc_y >= gc_scrreg_bottom)
786 gc_y = gc_scrreg_bottom - 1;
787 break;
788 case 'C': /* Right */
789 gc_x += gc_par[0] ? gc_par[0] : 1;
790 if (gc_x >= vinfo.v_columns)
791 gc_x = vinfo.v_columns-1;
792 break;
793 case 'D': /* Left */
794 if (gc_par[0] > gc_x)
795 gc_x = 0;
796 else if (gc_par[0])
797 gc_x -= gc_par[0];
798 else if (gc_x)
799 --gc_x;
800 break;
801 case 'H': /* Set cursor position */
802 case 'f':
803 gc_x = gc_par[1] ? gc_par[1] - 1 : 0;
804 gc_y = gc_par[0] ? gc_par[0] - 1 : 0;
805 if (gc_relative_origin)
806 gc_y += gc_scrreg_top;
807 gc_hanging_cursor = 0;
808 break;
809 case 'X': /* clear p1 characters */
810 if (gc_numpars) {
811 for (i = gc_x; i < gc_x + gc_par[0]; i++)
812 gc_paint_char(i, gc_y, ' ', ATTR_NONE);
813 }
814 break;
815 case 'J': /* Clear part of screen */
816 gc_clear_screen(gc_x, gc_y, 0, vinfo.v_rows, gc_par[0]);
817 break;
818 case 'K': /* Clear part of line */
819 gc_clear_line(gc_x, gc_y, gc_par[0]);
820 break;
821 case 'g': /* tab stops */
822 switch (gc_par[0]) {
823 case 1:
824 case 2: /* reset tab stops */
825 /* gc_reset_tabs(); */
826 break;
827 case 3: /* Clear every tabs */
828 {
829 for (i = 0; i <= vinfo.v_columns; i++)
830 gc_set_tab_stop(i, FALSE);
831 }
832 break;
833 case 0:
834 gc_set_tab_stop(gc_x, FALSE);
835 break;
836 }
837 break;
838 case 'm': /* Set attribute */
839 for (i = 0; i < gc_numpars; i++) {
840 switch (gc_par[i]) {
841 case 0:
842 gc_attr = ATTR_NONE;
843 gc_update_color(COLOR_BACKGROUND, FALSE);
844 gc_update_color(COLOR_FOREGROUND, TRUE );
845 break;
846 case 1:
847 gc_attr |= ATTR_BOLD;
848 break;
849 case 4:
850 gc_attr |= ATTR_UNDER;
851 break;
852 case 7:
853 gc_attr |= ATTR_REVERSE;
854 break;
855 case 22:
856 gc_attr &= ~ATTR_BOLD;
857 break;
858 case 24:
859 gc_attr &= ~ATTR_UNDER;
860 break;
861 case 27:
862 gc_attr &= ~ATTR_REVERSE;
863 break;
864 case 5:
865 case 25: /* blink/no blink */
866 break;
867 default:
868 if (gc_par[i] >= 30 && gc_par[i] <= 37)
869 gc_update_color(gc_par[i] - 30, TRUE);
870 if (gc_par[i] >= 40 && gc_par[i] <= 47)
871 gc_update_color(gc_par[i] - 40, FALSE);
872 break;
873 }
874 }
875 break;
876 case 'r': /* Set scroll region */
877 gc_x = gc_y = 0;
878 /* ensure top < bottom, and both within limits */
879 if ((gc_numpars > 0) && (gc_par[0] < vinfo.v_rows)) {
880 gc_scrreg_top = gc_par[0] ? gc_par[0] - 1 : 0;
881 } else {
882 gc_scrreg_top = 0;
883 }
884 if ((gc_numpars > 1) && (gc_par[1] <= vinfo.v_rows) && (gc_par[1] > gc_par[0])) {
885 gc_scrreg_bottom = gc_par[1];
886 if (gc_scrreg_bottom > vinfo.v_rows)
887 gc_scrreg_bottom = vinfo.v_rows;
888 } else {
889 gc_scrreg_bottom = vinfo.v_rows;
890 }
891 if (gc_relative_origin)
892 gc_y = gc_scrreg_top;
893 break;
894 }
895
896 }
897
898 static void
899 gc_putc_normal(unsigned char ch)
900 {
901 switch (ch) {
902 case '\a': /* Beep */
903 break;
904 case 127: /* Delete */
905 case '\b': /* Backspace */
906 if (gc_hanging_cursor) {
907 gc_hanging_cursor = 0;
908 } else
909 if (gc_x > 0) {
910 gc_x--;
911 }
912 break;
913 case '\t': /* Tab */
914 if (gc_buffer_tab_stops) while (gc_x < vinfo.v_columns && !gc_is_tab_stop(++gc_x));
915
916 if (gc_x >= vinfo.v_columns)
917 gc_x = vinfo.v_columns-1;
918 break;
919 case 0x0b:
920 case 0x0c:
921 case '\n': /* Line feed */
922 if (gc_y >= gc_scrreg_bottom -1 ) {
923 gc_scroll_up(1, gc_scrreg_top, gc_scrreg_bottom);
924 gc_y = gc_scrreg_bottom - 1;
925 } else {
926 gc_y++;
927 }
928 break;
929 case '\r': /* Carriage return */
930 gc_x = 0;
931 gc_hanging_cursor = 0;
932 break;
933 case 0x0e: /* Select G1 charset (Control-N) */
934 gc_charset_select = 1;
935 break;
936 case 0x0f: /* Select G0 charset (Control-O) */
937 gc_charset_select = 0;
938 break;
939 case 0x18 : /* CAN : cancel */
940 case 0x1A : /* like cancel */
941 /* well, i do nothing here, may be later */
942 break;
943 case '\033': /* Escape */
944 gc_vt100state = ESesc;
945 gc_hanging_cursor = 0;
946 break;
947 default:
948 if (ch >= ' ') {
949 if (gc_hanging_cursor) {
950 gc_x = 0;
951 if (gc_y >= gc_scrreg_bottom -1 ) {
952 gc_scroll_up(1, gc_scrreg_top, gc_scrreg_bottom);
953 gc_y = gc_scrreg_bottom - 1;
954 } else {
955 gc_y++;
956 }
957 gc_hanging_cursor = 0;
958 }
959 gc_paint_char(gc_x, gc_y, (ch >= 0x60 && ch <= 0x7f) ? ch + gc_charset[gc_charset_select]
960 : ch, gc_attr);
961 if (gc_x == vinfo.v_columns - 1) {
962 gc_hanging_cursor = gc_wrap_mode;
963 } else {
964 gc_x++;
965 }
966 }
967 break;
968 }
969
970 }
971
972 static void
973 gc_putc_square(unsigned char ch)
974 {
975 int i;
976
977 for (i = 0; i < MAXPARS; i++) {
978 gc_par[i] = 0;
979 }
980
981 gc_numpars = 0;
982 gc_vt100state = ESgetpars;
983
984 gc_putc_getpars(ch);
985
986 }
987
988 static void
989 gc_reset_screen(void)
990 {
991 gc_reset_vt100();
992 gc_x = gc_y = 0;
993 }
994
995 static void
996 gc_reset_tabs(void)
997 {
998 unsigned int i;
999
1000 if (!gc_buffer_tab_stops) return;
1001
1002 for (i = 0; i < vinfo.v_columns; i++) {
1003 gc_buffer_tab_stops[i] = ((i % 8) == 0);
1004 }
1005
1006 }
1007
1008 static void
1009 gc_set_tab_stop(unsigned int column, boolean_t enabled)
1010 {
1011 if (gc_buffer_tab_stops && (column < vinfo.v_columns)) {
1012 gc_buffer_tab_stops[column] = enabled;
1013 }
1014 }
1015
1016 static boolean_t gc_is_tab_stop(unsigned int column)
1017 {
1018 if (gc_buffer_tab_stops == NULL)
1019 return ((column % 8) == 0);
1020 if (column < vinfo.v_columns)
1021 return gc_buffer_tab_stops[column];
1022 else
1023 return FALSE;
1024 }
1025
1026 static void
1027 gc_reset_vt100(void)
1028 {
1029 gc_reset_tabs();
1030 gc_scrreg_top = 0;
1031 gc_scrreg_bottom = vinfo.v_rows;
1032 gc_attr = ATTR_NONE;
1033 gc_charset[0] = gc_charset[1] = 0;
1034 gc_charset_select = 0;
1035 gc_wrap_mode = 1;
1036 gc_relative_origin = 0;
1037 gc_update_color(COLOR_BACKGROUND, FALSE);
1038 gc_update_color(COLOR_FOREGROUND, TRUE);
1039 }
1040
1041 static void
1042 gc_scroll_down(int num, unsigned int top, unsigned int bottom)
1043 {
1044 if (!gc_buffer_size) return;
1045
1046 if ( bottom <= gc_buffer_rows )
1047 {
1048 unsigned char colorcodesave = gc_color_code;
1049 uint32_t column, row;
1050 uint32_t index, jump;
1051
1052 jump = num * gc_buffer_columns;
1053
1054 for ( row = bottom - 1 ; row >= top + num ; row-- )
1055 {
1056 index = row * gc_buffer_columns;
1057
1058 for ( column = 0 ; column < gc_buffer_columns ; index++, column++ )
1059 {
1060 if ( gc_buffer_attributes[index] != gc_buffer_attributes[index - jump] ||
1061 gc_buffer_characters[index] != gc_buffer_characters[index - jump] ||
1062 gc_buffer_colorcodes[index] != gc_buffer_colorcodes[index - jump] )
1063 {
1064 if ( gc_color_code != gc_buffer_colorcodes[index - jump] )
1065 {
1066 gc_update_color(COLOR_CODE_GET(gc_buffer_colorcodes[index - jump], TRUE ), TRUE );
1067 gc_update_color(COLOR_CODE_GET(gc_buffer_colorcodes[index - jump], FALSE), FALSE);
1068 }
1069
1070 if ( gc_buffer_colorcodes[index] != gc_buffer_colorcodes[index - jump] )
1071 {
1072 gc_ops.paint_char( /* xx */ column,
1073 /* yy */ row,
1074 /* ch */ gc_buffer_characters[index - jump],
1075 /* attrs */ gc_buffer_attributes[index - jump],
1076 /* ch_previous */ 0,
1077 /* attrs_previous */ 0 );
1078 }
1079 else
1080 {
1081 gc_ops.paint_char( /* xx */ column,
1082 /* yy */ row,
1083 /* ch */ gc_buffer_characters[index - jump],
1084 /* attrs */ gc_buffer_attributes[index - jump],
1085 /* ch_previous */ gc_buffer_characters[index],
1086 /* attrs_previous */ gc_buffer_attributes[index] );
1087 }
1088
1089 gc_buffer_attributes[index] = gc_buffer_attributes[index - jump];
1090 gc_buffer_characters[index] = gc_buffer_characters[index - jump];
1091 gc_buffer_colorcodes[index] = gc_buffer_colorcodes[index - jump];
1092 }
1093 }
1094 }
1095
1096 if ( colorcodesave != gc_color_code )
1097 {
1098 gc_update_color(COLOR_CODE_GET(colorcodesave, TRUE ), TRUE );
1099 gc_update_color(COLOR_CODE_GET(colorcodesave, FALSE), FALSE);
1100 }
1101
1102 /* Now set the freed up lines to the background colour */
1103
1104 for ( row = top ; row < top + num ; row++ )
1105 {
1106 index = row * gc_buffer_columns;
1107
1108 for ( column = 0 ; column < gc_buffer_columns ; index++, column++ )
1109 {
1110 if ( gc_buffer_attributes[index] != ATTR_NONE ||
1111 gc_buffer_characters[index] != ' ' ||
1112 gc_buffer_colorcodes[index] != gc_color_code )
1113 {
1114 if ( gc_buffer_colorcodes[index] != gc_color_code )
1115 {
1116 gc_ops.paint_char( /* xx */ column,
1117 /* yy */ row,
1118 /* ch */ ' ',
1119 /* attrs */ ATTR_NONE,
1120 /* ch_previous */ 0,
1121 /* attrs_previous */ 0 );
1122 }
1123 else
1124 {
1125 gc_ops.paint_char( /* xx */ column,
1126 /* yy */ row,
1127 /* ch */ ' ',
1128 /* attrs */ ATTR_NONE,
1129 /* ch_previous */ gc_buffer_characters[index],
1130 /* attrs_previous */ gc_buffer_attributes[index] );
1131 }
1132
1133 gc_buffer_attributes[index] = ATTR_NONE;
1134 gc_buffer_characters[index] = ' ';
1135 gc_buffer_colorcodes[index] = gc_color_code;
1136 }
1137 }
1138 }
1139 }
1140 else
1141 {
1142 gc_ops.scroll_down(num, top, bottom);
1143
1144 /* Now set the freed up lines to the background colour */
1145
1146 gc_clear_screen(vinfo.v_columns - 1, top + num - 1, top, bottom, 1);
1147 }
1148 }
1149
1150 static void
1151 gc_scroll_up(int num, unsigned int top, unsigned int bottom)
1152 {
1153 if (!gc_buffer_size) return;
1154
1155 if ( bottom <= gc_buffer_rows )
1156 {
1157 unsigned char colorcodesave = gc_color_code;
1158 uint32_t column, row;
1159 uint32_t index, jump;
1160
1161 jump = num * gc_buffer_columns;
1162
1163 for ( row = top ; row < bottom - num ; row++ )
1164 {
1165 index = row * gc_buffer_columns;
1166
1167 for ( column = 0 ; column < gc_buffer_columns ; index++, column++ )
1168 {
1169 if ( gc_buffer_attributes[index] != gc_buffer_attributes[index + jump] ||
1170 gc_buffer_characters[index] != gc_buffer_characters[index + jump] ||
1171 gc_buffer_colorcodes[index] != gc_buffer_colorcodes[index + jump] )
1172 {
1173 if ( gc_color_code != gc_buffer_colorcodes[index + jump] )
1174 {
1175 gc_update_color(COLOR_CODE_GET(gc_buffer_colorcodes[index + jump], TRUE ), TRUE );
1176 gc_update_color(COLOR_CODE_GET(gc_buffer_colorcodes[index + jump], FALSE), FALSE);
1177 }
1178
1179 if ( gc_buffer_colorcodes[index] != gc_buffer_colorcodes[index + jump] )
1180 {
1181 gc_ops.paint_char( /* xx */ column,
1182 /* yy */ row,
1183 /* ch */ gc_buffer_characters[index + jump],
1184 /* attrs */ gc_buffer_attributes[index + jump],
1185 /* ch_previous */ 0,
1186 /* attrs_previous */ 0 );
1187 }
1188 else
1189 {
1190 gc_ops.paint_char( /* xx */ column,
1191 /* yy */ row,
1192 /* ch */ gc_buffer_characters[index + jump],
1193 /* attrs */ gc_buffer_attributes[index + jump],
1194 /* ch_previous */ gc_buffer_characters[index],
1195 /* attrs_previous */ gc_buffer_attributes[index] );
1196 }
1197
1198 gc_buffer_attributes[index] = gc_buffer_attributes[index + jump];
1199 gc_buffer_characters[index] = gc_buffer_characters[index + jump];
1200 gc_buffer_colorcodes[index] = gc_buffer_colorcodes[index + jump];
1201 }
1202 }
1203 }
1204
1205 if ( colorcodesave != gc_color_code )
1206 {
1207 gc_update_color(COLOR_CODE_GET(colorcodesave, TRUE ), TRUE );
1208 gc_update_color(COLOR_CODE_GET(colorcodesave, FALSE), FALSE);
1209 }
1210
1211 /* Now set the freed up lines to the background colour */
1212
1213 for ( row = bottom - num ; row < bottom ; row++ )
1214 {
1215 index = row * gc_buffer_columns;
1216
1217 for ( column = 0 ; column < gc_buffer_columns ; index++, column++ )
1218 {
1219 if ( gc_buffer_attributes[index] != ATTR_NONE ||
1220 gc_buffer_characters[index] != ' ' ||
1221 gc_buffer_colorcodes[index] != gc_color_code )
1222 {
1223 if ( gc_buffer_colorcodes[index] != gc_color_code )
1224 {
1225 gc_ops.paint_char( /* xx */ column,
1226 /* yy */ row,
1227 /* ch */ ' ',
1228 /* attrs */ ATTR_NONE,
1229 /* ch_previous */ 0,
1230 /* attrs_previous */ 0 );
1231 }
1232 else
1233 {
1234 gc_ops.paint_char( /* xx */ column,
1235 /* yy */ row,
1236 /* ch */ ' ',
1237 /* attrs */ ATTR_NONE,
1238 /* ch_previous */ gc_buffer_characters[index],
1239 /* attrs_previous */ gc_buffer_attributes[index] );
1240 }
1241
1242 gc_buffer_attributes[index] = ATTR_NONE;
1243 gc_buffer_characters[index] = ' ';
1244 gc_buffer_colorcodes[index] = gc_color_code;
1245 }
1246 }
1247 }
1248 }
1249 else
1250 {
1251 gc_ops.scroll_up(num, top, bottom);
1252
1253 /* Now set the freed up lines to the background colour */
1254
1255 gc_clear_screen(0, bottom - num, top, bottom, 0);
1256 }
1257 }
1258
1259 static void
1260 gc_show_cursor(unsigned int xx, unsigned int yy)
1261 {
1262 if ( xx < gc_buffer_columns && yy < gc_buffer_rows )
1263 {
1264 uint32_t index = (yy * gc_buffer_columns) + xx;
1265 unsigned char attribute = gc_buffer_attributes[index];
1266 unsigned char character = gc_buffer_characters[index];
1267 unsigned char colorcode = gc_buffer_colorcodes[index];
1268 unsigned char colorcodesave = gc_color_code;
1269
1270 gc_update_color(COLOR_CODE_GET(colorcode, FALSE), TRUE );
1271 gc_update_color(COLOR_CODE_GET(colorcode, TRUE ), FALSE);
1272
1273 gc_ops.paint_char(xx, yy, character, attribute, 0, 0);
1274
1275 gc_update_color(COLOR_CODE_GET(colorcodesave, TRUE ), TRUE );
1276 gc_update_color(COLOR_CODE_GET(colorcodesave, FALSE), FALSE);
1277 }
1278 else
1279 {
1280 gc_ops.show_cursor(xx, yy);
1281 }
1282 }
1283
1284 static void
1285 gc_update_color(int color, boolean_t fore)
1286 {
1287 assert(gc_ops.update_color);
1288
1289 gc_color_code = COLOR_CODE_SET(gc_color_code, color, fore);
1290 gc_ops.update_color(color, fore);
1291 }
1292
1293 void
1294 vcputc(__unused int l, __unused int u, int c)
1295 {
1296 if ( gc_initialized && gc_enabled )
1297 {
1298 spl_t s;
1299
1300 s = splhigh();
1301 #if defined(__i386__) || defined(__x86_64__)
1302 x86_filter_TLB_coherency_interrupts(TRUE);
1303 #endif
1304 VCPUTC_LOCK_LOCK();
1305 if ( gc_enabled )
1306 {
1307 gc_hide_cursor(gc_x, gc_y);
1308 gc_putchar(c);
1309 gc_show_cursor(gc_x, gc_y);
1310 }
1311 VCPUTC_LOCK_UNLOCK();
1312 #if defined(__i386__) || defined(__x86_64__)
1313 x86_filter_TLB_coherency_interrupts(FALSE);
1314 #endif
1315 splx(s);
1316 }
1317 }
1318
1319 /*
1320 * Video Console (Back-End)
1321 * ------------------------
1322 */
1323
1324 /*
1325 * For the color support (Michel Pollet)
1326 */
1327 static unsigned char vc_color_index_table[33] =
1328 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1329 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 2 };
1330
1331 static uint32_t vc_colors[8][4] = {
1332 { 0xFFFFFFFF, 0x00000000, 0x00000000, 0x00000000 }, /* black */
1333 { 0x23232323, 0x7C007C00, 0x00FF0000, 0x3FF00000 }, /* red */
1334 { 0xb9b9b9b9, 0x03e003e0, 0x0000FF00, 0x000FFC00 }, /* green */
1335 { 0x05050505, 0x7FE07FE0, 0x00FFFF00, 0x3FFFFC00 }, /* yellow */
1336 { 0xd2d2d2d2, 0x001f001f, 0x000000FF, 0x000003FF }, /* blue */
1337 // { 0x80808080, 0x31933193, 0x00666699, 0x00000000 }, /* blue */
1338 { 0x18181818, 0x7C1F7C1F, 0x00FF00FF, 0x3FF003FF }, /* magenta */
1339 { 0xb4b4b4b4, 0x03FF03FF, 0x0000FFFF, 0x000FFFFF }, /* cyan */
1340 { 0x00000000, 0x7FFF7FFF, 0x00FFFFFF, 0x3FFFFFFF } /* white */
1341 };
1342
1343 static uint32_t vc_color_fore = 0;
1344 static uint32_t vc_color_back = 0;
1345
1346 /*
1347 * New Rendering code from Michel Pollet
1348 */
1349
1350 /* Rendered Font Buffer */
1351 static unsigned char *vc_rendered_font = NULL;
1352
1353 /* Rendered Font Size */
1354 static uint32_t vc_rendered_font_size = 0;
1355
1356 /* Size of a character in the table (bytes) */
1357 static int vc_rendered_char_size = 0;
1358
1359 #define REN_MAX_DEPTH 32
1360 static unsigned char vc_rendered_char[ISO_CHAR_HEIGHT * ((REN_MAX_DEPTH / 8) * ISO_CHAR_WIDTH)];
1361
1362 #if !CONFIG_EMBEDDED
1363 static void
1364 internal_set_progressmeter(int new_value);
1365 static void
1366 internal_enable_progressmeter(int new_value);
1367
1368 enum
1369 {
1370 kProgressMeterOff = FALSE,
1371 kProgressMeterUser = TRUE,
1372 kProgressMeterKernel = 3,
1373 };
1374 enum
1375 {
1376 kProgressMeterMax = 1024,
1377 kProgressMeterEnd = 512,
1378 };
1379
1380 #endif /* !CONFIG_EMBEDDED */
1381
1382 static boolean_t vc_progress_white =
1383 #ifdef CONFIG_VC_PROGRESS_WHITE
1384 TRUE;
1385 #else /* !CONFIG_VC_PROGRESS_WHITE */
1386 FALSE;
1387 #endif /* !CONFIG_VC_PROGRESS_WHITE */
1388
1389 static int vc_acquire_delay = kProgressAcquireDelay;
1390
1391 static void
1392 vc_clear_screen(unsigned int xx, unsigned int yy, unsigned int scrreg_top,
1393 unsigned int scrreg_bottom, int which)
1394 {
1395 uint32_t *p, *endp, *row;
1396 int linelongs, col;
1397 int rowline, rowlongs;
1398
1399 if(!vinfo.v_depth)
1400 return;
1401
1402 linelongs = vinfo.v_rowbytes * (ISO_CHAR_HEIGHT >> 2);
1403 rowline = vinfo.v_rowscanbytes >> 2;
1404 rowlongs = vinfo.v_rowbytes >> 2;
1405
1406 p = (uint32_t*) vinfo.v_baseaddr;
1407 endp = (uint32_t*) vinfo.v_baseaddr;
1408
1409 switch (which) {
1410 case 0: /* To end of screen */
1411 gc_clear_line(xx, yy, 0);
1412 if (yy < scrreg_bottom - 1) {
1413 p += (yy + 1) * linelongs;
1414 endp += scrreg_bottom * linelongs;
1415 }
1416 break;
1417 case 1: /* To start of screen */
1418 gc_clear_line(xx, yy, 1);
1419 if (yy > scrreg_top) {
1420 p += scrreg_top * linelongs;
1421 endp += yy * linelongs;
1422 }
1423 break;
1424 case 2: /* Whole screen */
1425 p += scrreg_top * linelongs;
1426 if (scrreg_bottom == vinfo.v_rows) {
1427 endp += rowlongs * vinfo.v_height;
1428 } else {
1429 endp += scrreg_bottom * linelongs;
1430 }
1431 break;
1432 }
1433
1434 for (row = p ; row < endp ; row += rowlongs) {
1435 for (col = 0; col < rowline; col++)
1436 *(row+col) = vc_color_back;
1437 }
1438 }
1439
1440 static void
1441 vc_render_char(unsigned char ch, unsigned char *renderptr, short newdepth)
1442 {
1443 union {
1444 unsigned char *charptr;
1445 unsigned short *shortptr;
1446 uint32_t *longptr;
1447 } current; /* current place in rendered font, multiple types. */
1448 unsigned char *theChar; /* current char in iso_font */
1449 int line;
1450
1451 current.charptr = renderptr;
1452 theChar = iso_font + (ch * ISO_CHAR_HEIGHT);
1453
1454 for (line = 0; line < ISO_CHAR_HEIGHT; line++) {
1455 unsigned char mask = 1;
1456 do {
1457 switch (newdepth) {
1458 case 8:
1459 *current.charptr++ = (*theChar & mask) ? 0xFF : 0;
1460 break;
1461 case 16:
1462 *current.shortptr++ = (*theChar & mask) ? 0xFFFF : 0;
1463 break;
1464
1465 case 30:
1466 case 32:
1467 *current.longptr++ = (*theChar & mask) ? 0xFFFFFFFF : 0;
1468 break;
1469 }
1470 mask <<= 1;
1471 } while (mask); /* while the single bit drops to the right */
1472 theChar++;
1473 }
1474 }
1475
1476 static void
1477 vc_paint_char_8(unsigned int xx, unsigned int yy, unsigned char ch, int attrs,
1478 __unused unsigned char ch_previous, __unused int attrs_previous)
1479 {
1480 uint32_t *theChar;
1481 uint32_t *where;
1482 int i;
1483
1484 if (vc_rendered_font) {
1485 theChar = (uint32_t*)(vc_rendered_font + (ch * vc_rendered_char_size));
1486 } else {
1487 vc_render_char(ch, vc_rendered_char, 8);
1488 theChar = (uint32_t*)(vc_rendered_char);
1489 }
1490 where = (uint32_t*)(vinfo.v_baseaddr +
1491 (yy * ISO_CHAR_HEIGHT * vinfo.v_rowbytes) +
1492 (xx * ISO_CHAR_WIDTH));
1493
1494 if (!attrs) for (i = 0; i < ISO_CHAR_HEIGHT; i++) { /* No attr? FLY !*/
1495 uint32_t *store = where;
1496 int x;
1497 for (x = 0; x < 2; x++) {
1498 uint32_t val = *theChar++;
1499 val = (vc_color_back & ~val) | (vc_color_fore & val);
1500 *store++ = val;
1501 }
1502
1503 where = (uint32_t*)(((unsigned char*)where)+vinfo.v_rowbytes);
1504 } else for (i = 0; i < ISO_CHAR_HEIGHT; i++) { /* a little slower */
1505 uint32_t *store = where, lastpixel = 0;
1506 int x;
1507 for (x = 0 ; x < 2; x++) {
1508 uint32_t val = *theChar++, save = val;
1509 if (attrs & ATTR_BOLD) { /* bold support */
1510 if (lastpixel && !(save & 0xFF000000))
1511 val |= 0xff000000;
1512 if ((save & 0xFFFF0000) == 0xFF000000)
1513 val |= 0x00FF0000;
1514 if ((save & 0x00FFFF00) == 0x00FF0000)
1515 val |= 0x0000FF00;
1516 if ((save & 0x0000FFFF) == 0x0000FF00)
1517 val |= 0x000000FF;
1518 }
1519 if (attrs & ATTR_REVERSE) val = ~val;
1520 if (attrs & ATTR_UNDER && i == ISO_CHAR_HEIGHT-1) val = ~val;
1521
1522 val = (vc_color_back & ~val) | (vc_color_fore & val);
1523 *store++ = val;
1524 lastpixel = save & 0xff;
1525 }
1526
1527 where = (uint32_t*)(((unsigned char*)where)+vinfo.v_rowbytes);
1528 }
1529
1530 }
1531
1532 static void
1533 vc_paint_char_16(unsigned int xx, unsigned int yy, unsigned char ch, int attrs,
1534 __unused unsigned char ch_previous,
1535 __unused int attrs_previous)
1536 {
1537 uint32_t *theChar;
1538 uint32_t *where;
1539 int i;
1540
1541 if (vc_rendered_font) {
1542 theChar = (uint32_t*)(vc_rendered_font + (ch * vc_rendered_char_size));
1543 } else {
1544 vc_render_char(ch, vc_rendered_char, 16);
1545 theChar = (uint32_t*)(vc_rendered_char);
1546 }
1547 where = (uint32_t*)(vinfo.v_baseaddr +
1548 (yy * ISO_CHAR_HEIGHT * vinfo.v_rowbytes) +
1549 (xx * ISO_CHAR_WIDTH * 2));
1550
1551 if (!attrs) for (i = 0; i < ISO_CHAR_HEIGHT; i++) { /* No attrs ? FLY ! */
1552 uint32_t *store = where;
1553 int x;
1554 for (x = 0; x < 4; x++) {
1555 uint32_t val = *theChar++;
1556 val = (vc_color_back & ~val) | (vc_color_fore & val);
1557 *store++ = val;
1558 }
1559
1560 where = (uint32_t*)(((unsigned char*)where)+vinfo.v_rowbytes);
1561 } else for (i = 0; i < ISO_CHAR_HEIGHT; i++) { /* a little bit slower */
1562 uint32_t *store = where, lastpixel = 0;
1563 int x;
1564 for (x = 0 ; x < 4; x++) {
1565 uint32_t val = *theChar++, save = val;
1566 if (attrs & ATTR_BOLD) { /* bold support */
1567 if (save == 0xFFFF0000) val |= 0xFFFF;
1568 else if (lastpixel && !(save & 0xFFFF0000))
1569 val |= 0xFFFF0000;
1570 }
1571 if (attrs & ATTR_REVERSE) val = ~val;
1572 if (attrs & ATTR_UNDER && i == ISO_CHAR_HEIGHT-1) val = ~val;
1573
1574 val = (vc_color_back & ~val) | (vc_color_fore & val);
1575
1576 *store++ = val;
1577 lastpixel = save & 0x7fff;
1578 }
1579
1580 where = (uint32_t*)(((unsigned char*)where)+vinfo.v_rowbytes);
1581 }
1582
1583 }
1584
1585 static void
1586 vc_paint_char_32(unsigned int xx, unsigned int yy, unsigned char ch, int attrs,
1587 unsigned char ch_previous, int attrs_previous)
1588 {
1589 uint32_t *theChar;
1590 uint32_t *theCharPrevious;
1591 uint32_t *where;
1592 int i;
1593
1594 if (vc_rendered_font) {
1595 theChar = (uint32_t*)(vc_rendered_font + (ch * vc_rendered_char_size));
1596 theCharPrevious = (uint32_t*)(vc_rendered_font + (ch_previous * vc_rendered_char_size));
1597 } else {
1598 vc_render_char(ch, vc_rendered_char, 32);
1599 theChar = (uint32_t*)(vc_rendered_char);
1600 theCharPrevious = NULL;
1601 }
1602 if (!ch_previous) {
1603 theCharPrevious = NULL;
1604 }
1605 if (attrs_previous) {
1606 theCharPrevious = NULL;
1607 }
1608 where = (uint32_t*)(vinfo.v_baseaddr +
1609 (yy * ISO_CHAR_HEIGHT * vinfo.v_rowbytes) +
1610 (xx * ISO_CHAR_WIDTH * 4));
1611
1612 if (!attrs) for (i = 0; i < ISO_CHAR_HEIGHT; i++) { /* No attrs ? FLY ! */
1613 uint32_t *store = where;
1614 int x;
1615 for (x = 0; x < 8; x++) {
1616 uint32_t val = *theChar++;
1617 if (theCharPrevious == NULL || val != *theCharPrevious++ ) {
1618 val = (vc_color_back & ~val) | (vc_color_fore & val);
1619 *store++ = val;
1620 } else {
1621 store++;
1622 }
1623 }
1624
1625 where = (uint32_t *)(((unsigned char*)where)+vinfo.v_rowbytes);
1626 } else for (i = 0; i < ISO_CHAR_HEIGHT; i++) { /* a little slower */
1627 uint32_t *store = where, lastpixel = 0;
1628 int x;
1629 for (x = 0 ; x < 8; x++) {
1630 uint32_t val = *theChar++, save = val;
1631 if (attrs & ATTR_BOLD) { /* bold support */
1632 if (lastpixel && !save)
1633 val = 0xFFFFFFFF;
1634 }
1635 if (attrs & ATTR_REVERSE) val = ~val;
1636 if (attrs & ATTR_UNDER && i == ISO_CHAR_HEIGHT-1) val = ~val;
1637
1638 val = (vc_color_back & ~val) | (vc_color_fore & val);
1639 *store++ = val;
1640 lastpixel = save;
1641 }
1642
1643 where = (uint32_t*)(((unsigned char*)where)+vinfo.v_rowbytes);
1644 }
1645
1646 }
1647
1648 static void
1649 vc_paint_char(unsigned int xx, unsigned int yy, unsigned char ch, int attrs,
1650 unsigned char ch_previous, int attrs_previous)
1651 {
1652 if(!vinfo.v_depth)
1653 return;
1654
1655 switch(vinfo.v_depth) {
1656 case 8:
1657 vc_paint_char_8(xx, yy, ch, attrs, ch_previous, attrs_previous);
1658 break;
1659 case 16:
1660 vc_paint_char_16(xx, yy, ch, attrs, ch_previous,
1661 attrs_previous);
1662 break;
1663 case 30:
1664 case 32:
1665 vc_paint_char_32(xx, yy, ch, attrs, ch_previous,
1666 attrs_previous);
1667 break;
1668 }
1669 }
1670
1671 static void
1672 vc_render_font(short newdepth)
1673 {
1674 static short olddepth = 0;
1675
1676 int charindex; /* index in ISO font */
1677 unsigned char *rendered_font;
1678 unsigned int rendered_font_size;
1679 int rendered_char_size;
1680 spl_t s;
1681
1682 if (vm_initialized == FALSE) {
1683 return; /* nothing to do */
1684 }
1685 if (olddepth == newdepth && vc_rendered_font) {
1686 return; /* nothing to do */
1687 }
1688
1689 s = splhigh();
1690 VCPUTC_LOCK_LOCK();
1691
1692 rendered_font = vc_rendered_font;
1693 rendered_font_size = vc_rendered_font_size;
1694 rendered_char_size = vc_rendered_char_size;
1695
1696 vc_rendered_font = NULL;
1697 vc_rendered_font_size = 0;
1698 vc_rendered_char_size = 0;
1699
1700 VCPUTC_LOCK_UNLOCK();
1701 splx(s);
1702
1703 if (rendered_font) {
1704 kfree(rendered_font, rendered_font_size);
1705 rendered_font = NULL;
1706 }
1707
1708 if (newdepth) {
1709 rendered_char_size = ISO_CHAR_HEIGHT * (((newdepth + 7) / 8) * ISO_CHAR_WIDTH);
1710 rendered_font_size = (ISO_CHAR_MAX-ISO_CHAR_MIN+1) * rendered_char_size;
1711 rendered_font = (unsigned char *) kalloc(rendered_font_size);
1712 }
1713
1714 if (rendered_font == NULL) {
1715 return;
1716 }
1717
1718 for (charindex = ISO_CHAR_MIN; charindex <= ISO_CHAR_MAX; charindex++) {
1719 vc_render_char(charindex, rendered_font + (charindex * rendered_char_size), newdepth);
1720 }
1721
1722 olddepth = newdepth;
1723
1724 s = splhigh();
1725 VCPUTC_LOCK_LOCK();
1726
1727 vc_rendered_font = rendered_font;
1728 vc_rendered_font_size = rendered_font_size;
1729 vc_rendered_char_size = rendered_char_size;
1730
1731 VCPUTC_LOCK_UNLOCK();
1732 splx(s);
1733 }
1734
1735 static void
1736 vc_enable(boolean_t enable)
1737 {
1738 vc_render_font(enable ? vinfo.v_depth : 0);
1739 }
1740
1741 static void
1742 vc_reverse_cursor(unsigned int xx, unsigned int yy)
1743 {
1744 uint32_t *where;
1745 int line, col;
1746
1747 if(!vinfo.v_depth)
1748 return;
1749
1750 where = (uint32_t*)(vinfo.v_baseaddr +
1751 (yy * ISO_CHAR_HEIGHT * vinfo.v_rowbytes) +
1752 (xx /** ISO_CHAR_WIDTH*/ * vinfo.v_depth));
1753 for (line = 0; line < ISO_CHAR_HEIGHT; line++) {
1754 switch (vinfo.v_depth) {
1755 case 8:
1756 where[0] = ~where[0];
1757 where[1] = ~where[1];
1758 break;
1759 case 16:
1760 for (col = 0; col < 4; col++)
1761 where[col] = ~where[col];
1762 break;
1763 case 32:
1764 for (col = 0; col < 8; col++)
1765 where[col] = ~where[col];
1766 break;
1767 }
1768 where = (uint32_t*)(((unsigned char*)where)+vinfo.v_rowbytes);
1769 }
1770 }
1771
1772 static void
1773 vc_scroll_down(int num, unsigned int scrreg_top, unsigned int scrreg_bottom)
1774 {
1775 uint32_t *from, *to, linelongs, i, line, rowline, rowscanline;
1776
1777 if(!vinfo.v_depth)
1778 return;
1779
1780 linelongs = vinfo.v_rowbytes * (ISO_CHAR_HEIGHT >> 2);
1781 rowline = vinfo.v_rowbytes >> 2;
1782 rowscanline = vinfo.v_rowscanbytes >> 2;
1783
1784 to = (uint32_t *) vinfo.v_baseaddr + (linelongs * scrreg_bottom)
1785 - (rowline - rowscanline);
1786 from = to - (linelongs * num); /* handle multiple line scroll (Michel Pollet) */
1787
1788 i = (scrreg_bottom - scrreg_top) - num;
1789
1790 while (i-- > 0) {
1791 for (line = 0; line < ISO_CHAR_HEIGHT; line++) {
1792 /*
1793 * Only copy what is displayed
1794 */
1795 video_scroll_down(from,
1796 (from-(vinfo.v_rowscanbytes >> 2)),
1797 to);
1798
1799 from -= rowline;
1800 to -= rowline;
1801 }
1802 }
1803 }
1804
1805 static void
1806 vc_scroll_up(int num, unsigned int scrreg_top, unsigned int scrreg_bottom)
1807 {
1808 uint32_t *from, *to, linelongs, i, line, rowline, rowscanline;
1809
1810 if(!vinfo.v_depth)
1811 return;
1812
1813 linelongs = vinfo.v_rowbytes * (ISO_CHAR_HEIGHT >> 2);
1814 rowline = vinfo.v_rowbytes >> 2;
1815 rowscanline = vinfo.v_rowscanbytes >> 2;
1816
1817 to = (uint32_t *) vinfo.v_baseaddr + (scrreg_top * linelongs);
1818 from = to + (linelongs * num); /* handle multiple line scroll (Michel Pollet) */
1819
1820 i = (scrreg_bottom - scrreg_top) - num;
1821
1822 while (i-- > 0) {
1823 for (line = 0; line < ISO_CHAR_HEIGHT; line++) {
1824 /*
1825 * Only copy what is displayed
1826 */
1827 video_scroll_up(from,
1828 (from+(vinfo.v_rowscanbytes >> 2)),
1829 to);
1830
1831 from += rowline;
1832 to += rowline;
1833 }
1834 }
1835 }
1836
1837 static void
1838 vc_update_color(int color, boolean_t fore)
1839 {
1840 if (!vinfo.v_depth)
1841 return;
1842 if (fore) {
1843 vc_color_fore = vc_colors[color][vc_color_index_table[vinfo.v_depth]];
1844 } else {
1845 vc_color_back = vc_colors[color][vc_color_index_table[vinfo.v_depth]];
1846 }
1847 }
1848
1849 /*
1850 * Video Console (Back-End): Icon Control
1851 * --------------------------------------
1852 */
1853
1854 static vc_progress_element * vc_progress;
1855 enum { kMaxProgressData = 3 };
1856 static const unsigned char * vc_progress_data[kMaxProgressData];
1857 static const unsigned char * vc_progress_alpha;
1858 static boolean_t vc_progress_enable;
1859 static const unsigned char * vc_clut;
1860 static const unsigned char * vc_clut8;
1861 static unsigned char vc_revclut8[256];
1862 static uint32_t vc_progress_interval;
1863 static uint32_t vc_progress_count;
1864 static uint32_t vc_progress_angle;
1865 static uint64_t vc_progress_deadline;
1866 static thread_call_data_t vc_progress_call;
1867 static boolean_t vc_needsave;
1868 static void * vc_saveunder;
1869 static vm_size_t vc_saveunder_len;
1870 static int8_t vc_uiscale = 1;
1871 vc_progress_user_options vc_progress_options;
1872 vc_progress_user_options vc_user_options;
1873
1874 decl_simple_lock_data(,vc_progress_lock)
1875
1876 #if !CONFIG_EMBEDDED
1877 static int vc_progress_withmeter = 3;
1878 int vc_progressmeter_enable;
1879 static int vc_progressmeter_drawn;
1880 int vc_progressmeter_value;
1881 static uint32_t vc_progressmeter_count;
1882 static uint32_t vc_progress_meter_start;
1883 static uint32_t vc_progress_meter_end;
1884 static uint64_t vc_progressmeter_interval;
1885 static uint64_t vc_progressmeter_deadline;
1886 static thread_call_data_t vc_progressmeter_call;
1887 static void * vc_progressmeter_backbuffer;
1888 static boolean_t vc_progressmeter_hold;
1889 static uint32_t vc_progressmeter_diskspeed = 256;
1890
1891 #endif /* !CONFIG_EMBEDDED */
1892
1893 enum {
1894 kSave = 0x10,
1895 kDataIndexed = 0x20,
1896 kDataAlpha = 0x40,
1897 kDataBack = 0x80,
1898 kDataRotate = 0x03,
1899 kDataRotate0 = 0,
1900 kDataRotate90 = 1,
1901 kDataRotate180 = 2,
1902 kDataRotate270 = 3
1903 };
1904
1905 static void vc_blit_rect(int x, int y, int bx,
1906 int width, int height,
1907 int sourceRow, int backRow,
1908 const unsigned char * dataPtr,
1909 void * backBuffer,
1910 unsigned int flags);
1911 static void vc_blit_rect_8(int x, int y, int bx,
1912 int width, int height,
1913 int sourceRow, int backRow,
1914 const unsigned char * dataPtr,
1915 unsigned char * backBuffer,
1916 unsigned int flags);
1917 static void vc_blit_rect_16(int x, int y, int bx,
1918 int width, int height,
1919 int sourceRow, int backRow,
1920 const unsigned char * dataPtr,
1921 unsigned short * backBuffer,
1922 unsigned int flags);
1923 static void vc_blit_rect_32(int x, int y, int bx,
1924 int width, int height,
1925 int sourceRow, int backRow,
1926 const unsigned char * dataPtr,
1927 unsigned int * backBuffer,
1928 unsigned int flags);
1929 static void vc_blit_rect_30(int x, int y, int bx,
1930 int width, int height,
1931 int sourceRow, int backRow,
1932 const unsigned char * dataPtr,
1933 unsigned int * backBuffer,
1934 unsigned int flags);
1935 static void vc_progress_task( void * arg0, void * arg );
1936 #if !CONFIG_EMBEDDED
1937 static void vc_progressmeter_task( void * arg0, void * arg );
1938 #endif /* !CONFIG_EMBEDDED */
1939
1940 static void vc_blit_rect(int x, int y, int bx,
1941 int width, int height,
1942 int sourceRow, int backRow,
1943 const unsigned char * dataPtr,
1944 void * backBuffer,
1945 unsigned int flags)
1946 {
1947 if (!vinfo.v_depth) return;
1948 if (((unsigned int)(x + width)) > vinfo.v_width) return;
1949 if (((unsigned int)(y + height)) > vinfo.v_height) return;
1950
1951 switch( vinfo.v_depth) {
1952 case 8:
1953 if( vc_clut8 == vc_clut)
1954 vc_blit_rect_8( x, y, bx, width, height, sourceRow, backRow, dataPtr, (unsigned char *) backBuffer, flags );
1955 break;
1956 case 16:
1957 vc_blit_rect_16( x, y, bx, width, height, sourceRow, backRow, dataPtr, (unsigned short *) backBuffer, flags );
1958 break;
1959 case 32:
1960 vc_blit_rect_32( x, y, bx, width, height, sourceRow, backRow, dataPtr, (unsigned int *) backBuffer, flags );
1961 break;
1962 case 30:
1963 vc_blit_rect_30( x, y, bx, width, height, sourceRow, backRow, dataPtr, (unsigned int *) backBuffer, flags );
1964 break;
1965 }
1966 }
1967
1968 static void
1969 vc_blit_rect_8(int x, int y, __unused int bx,
1970 int width, int height,
1971 int sourceRow, __unused int backRow,
1972 const unsigned char * dataPtr,
1973 __unused unsigned char * backBuffer,
1974 __unused unsigned int flags)
1975 {
1976 volatile unsigned short * dst;
1977 int line, col;
1978 unsigned int data = 0, out = 0;
1979 int sx, sy, a, b, c, d;
1980 int scale = 0x10000;
1981
1982 a = vc_rotate_matr[kDataRotate & flags][0][0] * scale;
1983 b = vc_rotate_matr[kDataRotate & flags][0][1] * scale;
1984 c = vc_rotate_matr[kDataRotate & flags][1][0] * scale;
1985 d = vc_rotate_matr[kDataRotate & flags][1][1] * scale;
1986 sx = ((a + b) < 0) ? ((width * scale) - 0x8000) : 0;
1987 sy = ((c + d) < 0) ? ((height * scale) - 0x8000) : 0;
1988
1989 if (!sourceRow) data = (unsigned int)(uintptr_t)dataPtr;
1990 else if (1 == sourceRow) a = 0;
1991
1992 dst = (volatile unsigned short *) (vinfo.v_baseaddr +
1993 (y * vinfo.v_rowbytes) +
1994 (x * 4));
1995
1996 for( line = 0; line < height; line++)
1997 {
1998 for( col = 0; col < width; col++)
1999 {
2000 if (sourceRow) data = dataPtr[((sx + (col * a) + (line * b)) >> 16)
2001 + sourceRow * (((sy + (col * c) + (line * d)) >> 16))];
2002 if (kDataAlpha & flags)
2003 out = vc_revclut8[data];
2004 else
2005 out = data;
2006 *(dst + col) = out;
2007 }
2008 dst = (volatile unsigned short *) (((volatile char*)dst) + vinfo.v_rowbytes);
2009 }
2010 }
2011
2012 /* For ARM, 16-bit is 565 (RGB); it is 1555 (XRGB) on other platforms */
2013
2014 #ifdef __arm__
2015 #define CLUT_MASK_R 0xf8
2016 #define CLUT_MASK_G 0xfc
2017 #define CLUT_MASK_B 0xf8
2018 #define CLUT_SHIFT_R << 8
2019 #define CLUT_SHIFT_G << 3
2020 #define CLUT_SHIFT_B >> 3
2021 #define MASK_R 0xf800
2022 #define MASK_G 0x07e0
2023 #define MASK_B 0x001f
2024 #define MASK_R_8 0x7f800
2025 #define MASK_G_8 0x01fe0
2026 #define MASK_B_8 0x000ff
2027 #else
2028 #define CLUT_MASK_R 0xf8
2029 #define CLUT_MASK_G 0xf8
2030 #define CLUT_MASK_B 0xf8
2031 #define CLUT_SHIFT_R << 7
2032 #define CLUT_SHIFT_G << 2
2033 #define CLUT_SHIFT_B >> 3
2034 #define MASK_R 0x7c00
2035 #define MASK_G 0x03e0
2036 #define MASK_B 0x001f
2037 #define MASK_R_8 0x3fc00
2038 #define MASK_G_8 0x01fe0
2039 #define MASK_B_8 0x000ff
2040 #endif
2041
2042 static void vc_blit_rect_16( int x, int y, int bx,
2043 int width, int height,
2044 int sourceRow, int backRow,
2045 const unsigned char * dataPtr,
2046 unsigned short * backPtr,
2047 unsigned int flags)
2048 {
2049 volatile unsigned short * dst;
2050 int line, col;
2051 unsigned int data = 0, out = 0, back = 0;
2052 int sx, sy, a, b, c, d;
2053 int scale = 0x10000;
2054
2055 a = vc_rotate_matr[kDataRotate & flags][0][0] * scale;
2056 b = vc_rotate_matr[kDataRotate & flags][0][1] * scale;
2057 c = vc_rotate_matr[kDataRotate & flags][1][0] * scale;
2058 d = vc_rotate_matr[kDataRotate & flags][1][1] * scale;
2059 sx = ((a + b) < 0) ? ((width * scale) - 0x8000) : 0;
2060 sy = ((c + d) < 0) ? ((height * scale) - 0x8000) : 0;
2061
2062 if (!sourceRow) data = (unsigned int)(uintptr_t)dataPtr;
2063 else if (1 == sourceRow) a = 0;
2064
2065 if (backPtr)
2066 backPtr += bx;
2067 dst = (volatile unsigned short *) (vinfo.v_baseaddr +
2068 (y * vinfo.v_rowbytes) +
2069 (x * 2));
2070
2071 for( line = 0; line < height; line++)
2072 {
2073 for( col = 0; col < width; col++)
2074 {
2075 if (sourceRow) data = dataPtr[((sx + (col * a) + (line * b)) >> 16)
2076 + sourceRow * (((sy + (col * c) + (line * d)) >> 16))];
2077 if (backPtr) {
2078 if (kSave & flags) {
2079 back = *(dst + col);
2080 *backPtr++ = back;
2081 } else
2082 back = *backPtr++;
2083 }
2084 if (kDataIndexed & flags) {
2085 out = ( (CLUT_MASK_R & (vc_clut[data*3 + 0])) CLUT_SHIFT_R)
2086 | ( (CLUT_MASK_G & (vc_clut[data*3 + 1])) CLUT_SHIFT_G)
2087 | ( (CLUT_MASK_B & (vc_clut[data*3 + 2])) CLUT_SHIFT_B);
2088 } else if (kDataAlpha & flags) {
2089 out = (((((back & MASK_R) * data) + MASK_R_8) >> 8) & MASK_R)
2090 | (((((back & MASK_G) * data) + MASK_G_8) >> 8) & MASK_G)
2091 | (((((back & MASK_B) * data) + MASK_B_8) >> 8) & MASK_B);
2092 if (vc_progress_white) out += (((0xff - data) & CLUT_MASK_R) CLUT_SHIFT_R)
2093 | (((0xff - data) & CLUT_MASK_G) CLUT_SHIFT_G)
2094 | (((0xff - data) & CLUT_MASK_B) CLUT_SHIFT_B);
2095 } else if (kDataBack & flags)
2096 out = back;
2097 else
2098 out = data;
2099 *(dst + col) = out;
2100 }
2101 dst = (volatile unsigned short *) (((volatile char*)dst) + vinfo.v_rowbytes);
2102 if (backPtr)
2103 backPtr += backRow - width;
2104 }
2105 }
2106
2107
2108 static void vc_blit_rect_32(int x, int y, int bx,
2109 int width, int height,
2110 int sourceRow, int backRow,
2111 const unsigned char * dataPtr,
2112 unsigned int * backPtr,
2113 unsigned int flags)
2114 {
2115 volatile unsigned int * dst;
2116 int line, col;
2117 unsigned int data = 0, out = 0, back = 0;
2118 int sx, sy, a, b, c, d;
2119 int scale = 0x10000;
2120
2121 a = vc_rotate_matr[kDataRotate & flags][0][0] * scale;
2122 b = vc_rotate_matr[kDataRotate & flags][0][1] * scale;
2123 c = vc_rotate_matr[kDataRotate & flags][1][0] * scale;
2124 d = vc_rotate_matr[kDataRotate & flags][1][1] * scale;
2125 sx = ((a + b) < 0) ? ((width * scale) - 0x8000) : 0;
2126 sy = ((c + d) < 0) ? ((height * scale) - 0x8000) : 0;
2127
2128 if (!sourceRow) data = (unsigned int)(uintptr_t)dataPtr;
2129 else if (1 == sourceRow) a = 0;
2130
2131 if (backPtr)
2132 backPtr += bx;
2133 dst = (volatile unsigned int *) (vinfo.v_baseaddr +
2134 (y * vinfo.v_rowbytes) +
2135 (x * 4));
2136
2137 for( line = 0; line < height; line++)
2138 {
2139 for( col = 0; col < width; col++)
2140 {
2141 if (sourceRow) data = dataPtr[((sx + (col * a) + (line * b)) >> 16)
2142 + sourceRow * (((sy + (col * c) + (line * d)) >> 16))];
2143 if (backPtr) {
2144 if (kSave & flags) {
2145 back = *(dst + col);
2146 *backPtr++ = back;
2147 } else
2148 back = *backPtr++;
2149 }
2150 if (kDataIndexed & flags) {
2151 out = (vc_clut[data*3 + 0] << 16)
2152 | (vc_clut[data*3 + 1] << 8)
2153 | (vc_clut[data*3 + 2]);
2154 } else if (kDataAlpha & flags) {
2155 out = (((((back & 0x00ff00ff) * data) + 0x00ff00ff) >> 8) & 0x00ff00ff)
2156 | (((((back & 0x0000ff00) * data) + 0x0000ff00) >> 8) & 0x0000ff00);
2157 if (vc_progress_white) out += ((0xff - data) << 16)
2158 | ((0xff - data) << 8)
2159 | (0xff - data);
2160 } else if (kDataBack & flags)
2161 out = back;
2162 else
2163 out = data;
2164 *(dst + col) = out;
2165 }
2166 dst = (volatile unsigned int *) (((volatile char*)dst) + vinfo.v_rowbytes);
2167 if (backPtr)
2168 backPtr += backRow - width;
2169 }
2170 }
2171
2172 static void vc_blit_rect_30(int x, int y, int bx,
2173 int width, int height,
2174 int sourceRow, int backRow,
2175 const unsigned char * dataPtr,
2176 unsigned int * backPtr,
2177 unsigned int flags)
2178 {
2179 volatile unsigned int * dst;
2180 int line, col;
2181 unsigned int data = 0, out = 0, back = 0;
2182 unsigned long long exp;
2183 int sx, sy, a, b, c, d;
2184 int scale = 0x10000;
2185
2186 a = vc_rotate_matr[kDataRotate & flags][0][0] * scale;
2187 b = vc_rotate_matr[kDataRotate & flags][0][1] * scale;
2188 c = vc_rotate_matr[kDataRotate & flags][1][0] * scale;
2189 d = vc_rotate_matr[kDataRotate & flags][1][1] * scale;
2190 sx = ((a + b) < 0) ? ((width * scale) - 0x8000) : 0;
2191 sy = ((c + d) < 0) ? ((height * scale) - 0x8000) : 0;
2192
2193 if (!sourceRow) data = (unsigned int)(uintptr_t)dataPtr;
2194 else if (1 == sourceRow) a = 0;
2195
2196 if (backPtr)
2197 backPtr += bx;
2198 dst = (volatile unsigned int *) (vinfo.v_baseaddr +
2199 (y * vinfo.v_rowbytes) +
2200 (x * 4));
2201
2202 for( line = 0; line < height; line++)
2203 {
2204 for( col = 0; col < width; col++)
2205 {
2206 if (sourceRow) data = dataPtr[((sx + (col * a) + (line * b)) >> 16)
2207 + sourceRow * (((sy + (col * c) + (line * d)) >> 16))];
2208 if (backPtr) {
2209 if (kSave & flags) {
2210 back = *(dst + col);
2211 *backPtr++ = back;
2212 } else
2213 back = *backPtr++;
2214 }
2215 if (kDataIndexed & flags) {
2216 out = (vc_clut[data*3 + 0] << 22)
2217 | (vc_clut[data*3 + 1] << 12)
2218 | (vc_clut[data*3 + 2] << 2);
2219 } else if (kDataAlpha & flags) {
2220 exp = back;
2221 exp = (((((exp & 0x3FF003FF) * data) + 0x0FF000FF) >> 8) & 0x3FF003FF)
2222 | (((((exp & 0x000FFC00) * data) + 0x0003FC00) >> 8) & 0x000FFC00);
2223 out = (unsigned int)exp;
2224 if (vc_progress_white) out += ((0xFF - data) << 22)
2225 | ((0xFF - data) << 12)
2226 | ((0xFF - data) << 2);
2227 } else if (kDataBack & flags)
2228 out = back;
2229 else
2230 out = data;
2231 *(dst + col) = out;
2232 }
2233 dst = (volatile unsigned int *) (((volatile char*)dst) + vinfo.v_rowbytes);
2234 if (backPtr)
2235 backPtr += backRow - width;
2236 }
2237 }
2238
2239 static void vc_clean_boot_graphics(void)
2240 {
2241 #if !CONFIG_EMBEDDED
2242 // clean up possible FDE login graphics
2243 vc_progress_set(FALSE, 0);
2244 const unsigned char *
2245 color = (typeof(color))(uintptr_t)(vc_progress_white ? 0x00000000 : 0xBFBFBFBF);
2246 vc_blit_rect(0, 0, 0, vinfo.v_width, vinfo.v_height, 0, 0, color, NULL, 0);
2247 #endif
2248 }
2249
2250 /*
2251 * Routines to render the lzss image format
2252 */
2253
2254 struct lzss_image_state {
2255 uint32_t col;
2256 uint32_t row;
2257 uint32_t width;
2258 uint32_t height;
2259 uint32_t bytes_per_row;
2260 volatile uint32_t * row_start;
2261 const uint8_t* clut;
2262 };
2263 typedef struct lzss_image_state lzss_image_state;
2264
2265 // returns 0 if OK, 1 if error
2266 static inline int
2267 vc_decompress_lzss_next_pixel (int next_data, lzss_image_state* state)
2268 {
2269 uint32_t palette_index = 0;
2270 uint32_t pixel_value = 0;
2271
2272 palette_index = next_data * 3;
2273
2274 pixel_value = ( (uint32_t) state->clut[palette_index + 0] << 16)
2275 | ( (uint32_t) state->clut[palette_index + 1] << 8)
2276 | ( (uint32_t) state->clut[palette_index + 2]);
2277
2278 *(state->row_start + state->col) = pixel_value;
2279
2280 if (++state->col >= state->width) {
2281 state->col = 0;
2282 if (++state->row >= state->height) {
2283 return 1;
2284 }
2285 state->row_start = (volatile uint32_t *) (((uintptr_t)state->row_start) + state->bytes_per_row);
2286 }
2287 return 0;
2288 }
2289
2290
2291 /*
2292 * Blit an lzss compressed image to the framebuffer
2293 * Assumes 32 bit screen (which is everything we ship at the moment)
2294 * The function vc_display_lzss_icon was copied from libkern/mkext.c, then modified.
2295 */
2296
2297 /*
2298 * TODO: Does lzss use too much stack? 4096 plus bytes...
2299 * Can probably chop it down by 1/2.
2300 */
2301
2302 /**************************************************************
2303 LZSS.C -- A Data Compression Program
2304 ***************************************************************
2305 4/6/1989 Haruhiko Okumura
2306 Use, distribute, and modify this program freely.
2307 Please send me your improved versions.
2308 PC-VAN SCIENCE
2309 NIFTY-Serve PAF01022
2310 CompuServe 74050,1022
2311
2312 **************************************************************/
2313
2314 #define N 4096 /* size of ring buffer - must be power of 2 */
2315 #define F 18 /* upper limit for match_length */
2316 #define THRESHOLD 2 /* encode string into position and length
2317 if match_length is greater than this */
2318
2319 // returns 0 if OK, 1 if error
2320 // x and y indicate upper left corner of image location on screen
2321 int
2322 vc_display_lzss_icon(uint32_t dst_x, uint32_t dst_y,
2323 uint32_t image_width, uint32_t image_height,
2324 const uint8_t *compressed_image,
2325 uint32_t compressed_size,
2326 const uint8_t *clut)
2327 {
2328 uint32_t* image_start;
2329 uint32_t bytes_per_pixel = 4;
2330 uint32_t bytes_per_row = vinfo.v_rowbytes;
2331
2332 vc_clean_boot_graphics();
2333
2334 image_start = (uint32_t *) (vinfo.v_baseaddr + (dst_y * bytes_per_row) + (dst_x * bytes_per_pixel));
2335
2336 lzss_image_state state = {0, 0, image_width, image_height, bytes_per_row, image_start, clut};
2337
2338 int rval = 0;
2339
2340 const uint8_t *src = compressed_image;
2341 uint32_t srclen = compressed_size;
2342
2343 /* ring buffer of size N, with extra F-1 bytes to aid string comparison */
2344 uint8_t text_buf[N + F - 1];
2345 const uint8_t *srcend = src + srclen;
2346 int i, j, k, r, c;
2347 unsigned int flags;
2348
2349 srcend = src + srclen;
2350 for (i = 0; i < N - F; i++)
2351 text_buf[i] = ' ';
2352 r = N - F;
2353 flags = 0;
2354 for ( ; ; ) {
2355 if (((flags >>= 1) & 0x100) == 0) {
2356 if (src < srcend) c = *src++; else break;
2357 flags = c | 0xFF00; /* uses higher byte cleverly */
2358 } /* to count eight */
2359 if (flags & 1) {
2360 if (src < srcend) c = *src++; else break;
2361 rval = vc_decompress_lzss_next_pixel(c, &state);
2362 if (rval != 0)
2363 return rval;
2364 text_buf[r++] = c;
2365 r &= (N - 1);
2366 } else {
2367 if (src < srcend) i = *src++; else break;
2368 if (src < srcend) j = *src++; else break;
2369 i |= ((j & 0xF0) << 4);
2370 j = (j & 0x0F) + THRESHOLD;
2371 for (k = 0; k <= j; k++) {
2372 c = text_buf[(i + k) & (N - 1)];
2373 rval = vc_decompress_lzss_next_pixel(c, &state);
2374 if (rval != 0 )
2375 return rval;
2376 text_buf[r++] = c;
2377 r &= (N - 1);
2378 }
2379 }
2380 }
2381 return 0;
2382 }
2383
2384 void noroot_icon_test(void) {
2385 boolean_t o_vc_progress_enable = vc_progress_enable;
2386
2387 vc_progress_enable = 1;
2388
2389 PE_display_icon( 0, "noroot");
2390
2391 vc_progress_enable = o_vc_progress_enable;
2392 }
2393
2394
2395 void vc_display_icon( vc_progress_element * desc,
2396 const unsigned char * data )
2397 {
2398 int x, y, width, height;
2399
2400 if( vc_progress_enable && vc_clut) {
2401
2402 vc_clean_boot_graphics();
2403
2404 width = desc->width;
2405 height = desc->height;
2406 x = desc->dx;
2407 y = desc->dy;
2408 if( 1 & desc->flags) {
2409 x += ((vinfo.v_width - width) / 2);
2410 y += ((vinfo.v_height - height) / 2);
2411 }
2412 vc_blit_rect( x, y, 0, width, height, width, 0, data, NULL, kDataIndexed );
2413 }
2414 }
2415
2416 void
2417 vc_progress_initialize( vc_progress_element * desc,
2418 const unsigned char * data1x,
2419 const unsigned char * data2x,
2420 const unsigned char * data3x,
2421 const unsigned char * clut )
2422 {
2423 uint64_t abstime;
2424
2425 if( (!clut) || (!desc) || (!data1x))
2426 return;
2427 vc_clut = clut;
2428 vc_clut8 = clut;
2429
2430 vc_progress = desc;
2431 vc_progress_data[0] = data1x;
2432 vc_progress_data[1] = data2x;
2433 vc_progress_data[2] = data3x;
2434 if( 2 & vc_progress->flags)
2435 vc_progress_alpha = data1x
2436 + vc_progress->count * vc_progress->width * vc_progress->height;
2437 else
2438 vc_progress_alpha = NULL;
2439
2440 thread_call_setup(&vc_progress_call, vc_progress_task, NULL);
2441 clock_interval_to_absolutetime_interval(vc_progress->time, 1000 * 1000, &abstime);
2442 vc_progress_interval = (uint32_t)abstime;
2443
2444 #if !CONFIG_EMBEDDED
2445 thread_call_setup(&vc_progressmeter_call, vc_progressmeter_task, NULL);
2446 clock_interval_to_absolutetime_interval(1000 / 8, 1000 * 1000, &abstime);
2447 vc_progressmeter_interval = (uint32_t)abstime;
2448 #endif /* !CONFIG_EMBEDDED */
2449
2450 }
2451
2452 void
2453 vc_progress_set(boolean_t enable, uint32_t vc_delay)
2454 {
2455 spl_t s;
2456 void *saveBuf = NULL;
2457 vm_size_t saveLen = 0;
2458 unsigned int count;
2459 unsigned int index;
2460 unsigned char pdata8;
2461 unsigned short pdata16;
2462 unsigned short * buf16;
2463 unsigned int pdata32;
2464 unsigned int * buf32;
2465
2466 #if !CONFIG_EMBEDDED
2467
2468 if (kBootArgsFlagBlack & ((boot_args *) PE_state.bootArgs)->flags) return;
2469
2470 if (1 & vc_progress_withmeter)
2471 {
2472 if (enable) internal_enable_progressmeter(kProgressMeterKernel);
2473
2474 s = splhigh();
2475 simple_lock(&vc_progress_lock);
2476
2477 if( vc_progress_enable != enable) {
2478 vc_progress_enable = enable;
2479 if( enable)
2480 {
2481 vc_progressmeter_count = 0;
2482 clock_interval_to_deadline(vc_delay,
2483 1000 * 1000 * 1000 /*second scale*/,
2484 &vc_progressmeter_deadline);
2485 thread_call_enter_delayed(&vc_progressmeter_call, vc_progressmeter_deadline);
2486 }
2487 else thread_call_cancel(&vc_progressmeter_call);
2488 }
2489
2490 simple_unlock(&vc_progress_lock);
2491 splx(s);
2492
2493 if (!enable) internal_enable_progressmeter(kProgressMeterOff);
2494 return;
2495 }
2496
2497 #endif /* !CONFIG_EMBEDDED */
2498
2499 if(!vc_progress) return;
2500
2501 if( enable) {
2502 saveLen = (vc_progress->width * vc_uiscale) * (vc_progress->height * vc_uiscale) * ((vinfo.v_depth + 7) / 8);
2503 saveBuf = kalloc( saveLen );
2504
2505 switch( vinfo.v_depth) {
2506 case 8 :
2507 for( count = 0; count < 256; count++) {
2508 vc_revclut8[count] = vc_clut[0x01 * 3];
2509 pdata8 = (vc_clut[0x01 * 3] * count + 0x0ff) >> 8;
2510 for( index = 0; index < 256; index++) {
2511 if( (pdata8 == vc_clut[index * 3 + 0]) &&
2512 (pdata8 == vc_clut[index * 3 + 1]) &&
2513 (pdata8 == vc_clut[index * 3 + 2])) {
2514 vc_revclut8[count] = index;
2515 break;
2516 }
2517 }
2518 }
2519 memset( saveBuf, 0x01, saveLen );
2520 break;
2521
2522 case 16 :
2523 buf16 = (unsigned short *) saveBuf;
2524 pdata16 = ((vc_clut[0x01 * 3 + 0] & CLUT_MASK_R) CLUT_SHIFT_R)
2525 | ((vc_clut[0x01 * 3 + 0] & CLUT_MASK_G) CLUT_SHIFT_G)
2526 | ((vc_clut[0x01 * 3 + 0] & CLUT_MASK_B) CLUT_SHIFT_B);
2527 for( count = 0; count < saveLen / 2; count++)
2528 buf16[count] = pdata16;
2529 break;
2530
2531 case 32 :
2532 buf32 = (unsigned int *) saveBuf;
2533 pdata32 = ((vc_clut[0x01 * 3 + 0] & 0xff) << 16)
2534 | ((vc_clut[0x01 * 3 + 1] & 0xff) << 8)
2535 | ((vc_clut[0x01 * 3 + 2] & 0xff) << 0);
2536 for( count = 0; count < saveLen / 4; count++)
2537 buf32[count] = pdata32;
2538 break;
2539 }
2540 }
2541
2542 s = splhigh();
2543 simple_lock(&vc_progress_lock);
2544
2545 if( vc_progress_enable != enable) {
2546 vc_progress_enable = enable;
2547 if( enable) {
2548 vc_needsave = TRUE;
2549 vc_saveunder = saveBuf;
2550 vc_saveunder_len = saveLen;
2551 saveBuf = NULL;
2552 saveLen = 0;
2553 vc_progress_count = 0;
2554 vc_progress_angle = 0;
2555
2556 clock_interval_to_deadline(vc_delay,
2557 1000 * 1000 * 1000 /*second scale*/,
2558 &vc_progress_deadline);
2559 thread_call_enter_delayed(&vc_progress_call, vc_progress_deadline);
2560
2561 } else {
2562 if( vc_saveunder) {
2563 saveBuf = vc_saveunder;
2564 saveLen = vc_saveunder_len;
2565 vc_saveunder = NULL;
2566 vc_saveunder_len = 0;
2567 }
2568
2569 thread_call_cancel(&vc_progress_call);
2570 }
2571 }
2572
2573 simple_unlock(&vc_progress_lock);
2574 splx(s);
2575
2576 if( saveBuf)
2577 kfree( saveBuf, saveLen );
2578 }
2579
2580 #if !CONFIG_EMBEDDED
2581
2582 static uint32_t vc_progressmeter_range(uint32_t pos)
2583 {
2584 uint32_t ret;
2585
2586 if (pos > kProgressMeterEnd) pos = kProgressMeterEnd;
2587 ret = vc_progress_meter_start
2588 + ((pos * (vc_progress_meter_end - vc_progress_meter_start)) / kProgressMeterEnd);
2589
2590 return (ret);
2591 }
2592
2593 static void
2594 vc_progressmeter_task(__unused void *arg0, __unused void *arg)
2595 {
2596 spl_t s;
2597 uint64_t interval;
2598
2599 s = splhigh();
2600 simple_lock(&vc_progress_lock);
2601 if (vc_progressmeter_enable)
2602 {
2603 uint32_t pos = (vc_progressmeter_count >> 13);
2604 internal_set_progressmeter(vc_progressmeter_range(pos));
2605 if (pos < kProgressMeterEnd)
2606 {
2607 static uint16_t incr[8] = { 10000, 10000, 8192, 4096, 2048, 384, 384, 64 };
2608 vc_progressmeter_count += incr[(pos * 8) / kProgressMeterEnd];
2609
2610 interval = vc_progressmeter_interval;
2611 interval = ((interval * 256) / vc_progressmeter_diskspeed);
2612
2613 clock_deadline_for_periodic_event(interval, mach_absolute_time(), &vc_progressmeter_deadline);
2614 thread_call_enter_delayed(&vc_progressmeter_call, vc_progressmeter_deadline);
2615 }
2616 }
2617 simple_unlock(&vc_progress_lock);
2618 splx(s);
2619 }
2620
2621 void vc_progress_setdiskspeed(uint32_t speed)
2622 {
2623 vc_progressmeter_diskspeed = speed;
2624 }
2625
2626 #endif /* !CONFIG_EMBEDDED */
2627
2628 static void
2629 vc_progress_task(__unused void *arg0, __unused void *arg)
2630 {
2631 spl_t s;
2632 int x, y, width, height;
2633 uint64_t x_pos, y_pos;
2634 const unsigned char * data;
2635
2636 s = splhigh();
2637 simple_lock(&vc_progress_lock);
2638
2639 if( vc_progress_enable) do {
2640
2641 vc_progress_count++;
2642 if( vc_progress_count >= vc_progress->count) {
2643 vc_progress_count = 0;
2644 vc_progress_angle++;
2645 }
2646
2647 width = (vc_progress->width * vc_uiscale);
2648 height = (vc_progress->height * vc_uiscale);
2649 data = vc_progress_data[vc_uiscale - 1];
2650 if (!data) break;
2651
2652 if (kVCUsePosition & vc_progress_options.options) {
2653 /* Rotation: 0:normal, 1:right 90, 2:left 180, 3:left 90 */
2654 switch (3 & vinfo.v_rotate) {
2655 case 0:
2656 x_pos = vc_progress_options.x_pos;
2657 y_pos = vc_progress_options.y_pos;
2658 break;
2659 case 2:
2660 x_pos = 0xFFFFFFFF - vc_progress_options.x_pos;
2661 y_pos = 0xFFFFFFFF - vc_progress_options.y_pos;
2662 break;
2663 case 1:
2664 x_pos = 0xFFFFFFFF - vc_progress_options.y_pos;
2665 y_pos = vc_progress_options.x_pos;
2666 break;
2667 case 3:
2668 x_pos = vc_progress_options.y_pos;
2669 y_pos = 0xFFFFFFFF - vc_progress_options.x_pos;
2670 break;
2671 }
2672 x = (uint32_t)((x_pos * (uint64_t) vinfo.v_width) / 0xFFFFFFFFULL);
2673 y = (uint32_t)((y_pos * (uint64_t) vinfo.v_height) / 0xFFFFFFFFULL);
2674 x -= (width / 2);
2675 y -= (height / 2);
2676 } else {
2677 x = (vc_progress->dx * vc_uiscale);
2678 y = (vc_progress->dy * vc_uiscale);
2679 if( 1 & vc_progress->flags) {
2680 x += ((vinfo.v_width - width) / 2);
2681 y += ((vinfo.v_height - height) / 2);
2682 }
2683 }
2684
2685 if ((x + width) > (int)vinfo.v_width) break;
2686 if ((y + height) > (int)vinfo.v_height) break;
2687
2688 data += vc_progress_count * width * height;
2689
2690 vc_blit_rect( x, y, 0,
2691 width, height, width, width,
2692 data, vc_saveunder,
2693 kDataAlpha
2694 | (vc_progress_angle & kDataRotate)
2695 | (vc_needsave ? kSave : 0) );
2696 vc_needsave = FALSE;
2697
2698 clock_deadline_for_periodic_event(vc_progress_interval, mach_absolute_time(), &vc_progress_deadline);
2699 thread_call_enter_delayed(&vc_progress_call, vc_progress_deadline);
2700 }
2701 while (FALSE);
2702 simple_unlock(&vc_progress_lock);
2703 splx(s);
2704 }
2705
2706 /*
2707 * Generic Console (Front-End): Master Control
2708 * -------------------------------------------
2709 */
2710
2711 #if defined (__i386__) || defined (__x86_64__)
2712 #include <pexpert/i386/boot.h>
2713 #endif
2714
2715 static boolean_t gc_acquired = FALSE;
2716 static boolean_t gc_graphics_boot = FALSE;
2717 static boolean_t gc_desire_text = FALSE;
2718 static boolean_t gc_paused_progress;
2719
2720 static vm_offset_t lastVideoVirt = 0;
2721 static vm_size_t lastVideoMapSize = 0;
2722 static boolean_t lastVideoMapKmap = FALSE;
2723
2724 static void
2725 gc_pause( boolean_t pause, boolean_t graphics_now )
2726 {
2727 spl_t s;
2728
2729 s = splhigh( );
2730 VCPUTC_LOCK_LOCK( );
2731
2732 disableConsoleOutput = (pause && !console_is_serial());
2733 gc_enabled = (!pause && !graphics_now);
2734
2735 VCPUTC_LOCK_UNLOCK( );
2736
2737 simple_lock(&vc_progress_lock);
2738
2739 if (pause)
2740 {
2741 gc_paused_progress = vc_progress_enable;
2742 vc_progress_enable = FALSE;
2743 }
2744 else vc_progress_enable = gc_paused_progress;
2745
2746 if (vc_progress_enable)
2747 {
2748 #if !CONFIG_EMBEDDED
2749 if (1 & vc_progress_withmeter) thread_call_enter_delayed(&vc_progressmeter_call, vc_progressmeter_deadline);
2750 else
2751 #endif /* !CONFIG_EMBEDDED */
2752 thread_call_enter_delayed(&vc_progress_call, vc_progress_deadline);
2753 }
2754
2755 simple_unlock(&vc_progress_lock);
2756 splx(s);
2757 }
2758
2759 static void
2760 vc_initialize(__unused struct vc_info * vinfo_p)
2761 {
2762 #ifdef __arm__
2763 unsigned long cnt, data16, data32;
2764
2765 if (vinfo.v_depth == 16) {
2766 for (cnt = 0; cnt < 8; cnt++) {
2767 data32 = vc_colors[cnt][2];
2768 data16 = (data32 & 0x0000F8) << 8;
2769 data16 |= (data32 & 0x00FC00) >> 5;
2770 data16 |= (data32 & 0xF80000) >> 19;
2771 data16 |= data16 << 16;
2772 vc_colors[cnt][1] = data16;
2773 }
2774 }
2775 #endif
2776
2777 vinfo.v_rows = vinfo.v_height / ISO_CHAR_HEIGHT;
2778 vinfo.v_columns = vinfo.v_width / ISO_CHAR_WIDTH;
2779 vinfo.v_rowscanbytes = ((vinfo.v_depth + 7) / 8) * vinfo.v_width;
2780 vc_uiscale = vinfo.v_scale;
2781 if (vc_uiscale > kMaxProgressData) vc_uiscale = kMaxProgressData;
2782 else if (!vc_uiscale) vc_uiscale = 1;
2783 }
2784
2785 void
2786 initialize_screen(PE_Video * boot_vinfo, unsigned int op)
2787 {
2788 unsigned int newMapSize = 0;
2789 vm_offset_t newVideoVirt = 0;
2790 boolean_t graphics_now;
2791 uint32_t delay;
2792
2793 if ( boot_vinfo )
2794 {
2795 struct vc_info new_vinfo = vinfo;
2796 boolean_t makeMapping = FALSE;
2797
2798 /*
2799 * Copy parameters
2800 */
2801 if (kPEBaseAddressChange != op)
2802 {
2803 new_vinfo.v_width = (unsigned int)boot_vinfo->v_width;
2804 new_vinfo.v_height = (unsigned int)boot_vinfo->v_height;
2805 new_vinfo.v_depth = (unsigned int)boot_vinfo->v_depth;
2806 new_vinfo.v_rowbytes = (unsigned int)boot_vinfo->v_rowBytes;
2807 if (kernel_map == VM_MAP_NULL) {
2808 // only booter supplies HW rotation
2809 new_vinfo.v_rotate = (unsigned int)boot_vinfo->v_rotate;
2810 }
2811 #if defined(__i386__) || defined(__x86_64__)
2812 new_vinfo.v_type = (unsigned int)boot_vinfo->v_display;
2813 #else
2814 new_vinfo.v_type = 0;
2815 #endif
2816 unsigned int scale = (unsigned int)boot_vinfo->v_scale;
2817 if (scale == kPEScaleFactor1x )
2818 new_vinfo.v_scale = kPEScaleFactor1x;
2819 else if (scale == kPEScaleFactor2x)
2820 new_vinfo.v_scale = kPEScaleFactor2x;
2821 else /* Scale factor not set, default to 1x */
2822 new_vinfo.v_scale = kPEScaleFactor1x;
2823 }
2824 new_vinfo.v_name[0] = 0;
2825 new_vinfo.v_physaddr = 0;
2826
2827 /*
2828 * Check if we are have to map the framebuffer
2829 * If VM is up, we are given a virtual address, unless b0 is set to indicate physical.
2830 */
2831 newVideoVirt = boot_vinfo->v_baseAddr;
2832 makeMapping = (kernel_map == VM_MAP_NULL) || (0 != (1 & newVideoVirt));
2833 if (makeMapping)
2834 {
2835 newVideoVirt = 0;
2836 new_vinfo.v_physaddr = boot_vinfo->v_baseAddr & ~3UL; /* Get the physical address */
2837 #ifndef __LP64__
2838 new_vinfo.v_physaddr |= (((uint64_t) boot_vinfo->v_baseAddrHigh) << 32);
2839 #endif
2840 kprintf("initialize_screen: b=%08llX, w=%08X, h=%08X, r=%08X, d=%08X\n", /* (BRINGUP) */
2841 new_vinfo.v_physaddr, new_vinfo.v_width, new_vinfo.v_height, new_vinfo.v_rowbytes, new_vinfo.v_type); /* (BRINGUP) */
2842 }
2843
2844 if (!newVideoVirt && !new_vinfo.v_physaddr) /* Check to see if we have a framebuffer */
2845 {
2846 kprintf("initialize_screen: No video - forcing serial mode\n"); /* (BRINGUP) */
2847 new_vinfo.v_depth = 0; /* vc routines are nop */
2848 (void)switch_to_serial_console(); /* Switch into serial mode */
2849 gc_graphics_boot = FALSE; /* Say we are not in graphics mode */
2850 disableConsoleOutput = FALSE; /* Allow printfs to happen */
2851 gc_acquired = TRUE;
2852 }
2853 else
2854 {
2855 if (makeMapping)
2856 {
2857 unsigned int flags = VM_WIMG_IO;
2858 if (boot_vinfo->v_length != 0)
2859 newMapSize = (unsigned int) round_page(boot_vinfo->v_length);
2860 else
2861 newMapSize = (unsigned int) round_page(new_vinfo.v_height * new_vinfo.v_rowbytes); /* Remember size */
2862 newVideoVirt = io_map_spec((vm_map_offset_t)new_vinfo.v_physaddr, newMapSize, flags); /* Allocate address space for framebuffer */
2863 }
2864 new_vinfo.v_baseaddr = newVideoVirt + boot_vinfo->v_offset; /* Set the new framebuffer address */
2865 }
2866
2867 #if defined(__x86_64__)
2868 // Adjust the video buffer pointer to point to where it is in high virtual (above the hole)
2869 new_vinfo.v_baseaddr |= (VM_MIN_KERNEL_ADDRESS & ~LOW_4GB_MASK);
2870 #endif
2871
2872 /* Update the vinfo structure atomically with respect to the vc_progress task if running */
2873 if (vc_progress)
2874 {
2875 simple_lock(&vc_progress_lock);
2876 vinfo = new_vinfo;
2877 simple_unlock(&vc_progress_lock);
2878 }
2879 else
2880 {
2881 vinfo = new_vinfo;
2882 }
2883
2884 // If we changed the virtual address, remove the old mapping
2885 if (newVideoVirt != 0)
2886 {
2887 if (lastVideoVirt && lastVideoMapSize) /* Was the framebuffer mapped before? */
2888 {
2889 /* XXX why only !4K? */
2890 if (!TEST_PAGE_SIZE_4K && lastVideoMapSize)
2891 {
2892 pmap_remove(kernel_pmap, trunc_page_64(lastVideoVirt),
2893 round_page_64(lastVideoVirt + lastVideoMapSize)); /* Toss mappings */
2894 }
2895 /* Was this not a special pre-VM mapping? */
2896 if (lastVideoMapKmap)
2897 {
2898 kmem_free(kernel_map, lastVideoVirt, lastVideoMapSize); /* Toss kernel addresses */
2899 }
2900 }
2901 lastVideoMapKmap = (NULL != kernel_map); /* Remember how mapped */
2902 lastVideoMapSize = newMapSize; /* Remember the size */
2903 lastVideoVirt = newVideoVirt; /* Remember the virtual framebuffer address */
2904 }
2905
2906 if (kPEBaseAddressChange != op)
2907 {
2908 // Graphics mode setup by the booter.
2909
2910 gc_ops.initialize = vc_initialize;
2911 gc_ops.enable = vc_enable;
2912 gc_ops.paint_char = vc_paint_char;
2913 gc_ops.scroll_down = vc_scroll_down;
2914 gc_ops.scroll_up = vc_scroll_up;
2915 gc_ops.clear_screen = vc_clear_screen;
2916 gc_ops.hide_cursor = vc_reverse_cursor;
2917 gc_ops.show_cursor = vc_reverse_cursor;
2918 gc_ops.update_color = vc_update_color;
2919 gc_initialize(&vinfo);
2920 }
2921 }
2922
2923 graphics_now = gc_graphics_boot && !gc_desire_text;
2924 switch ( op )
2925 {
2926 case kPEGraphicsMode:
2927 gc_graphics_boot = TRUE;
2928 gc_desire_text = FALSE;
2929 break;
2930
2931 case kPETextMode:
2932 gc_graphics_boot = FALSE;
2933 break;
2934
2935 case kPEAcquireScreen:
2936 if ( gc_acquired ) break;
2937
2938 vc_progress_options = vc_user_options;
2939 bzero(&vc_user_options, sizeof(vc_user_options));
2940
2941 if (kVCAcquireImmediate & vc_progress_options.options) delay = 0;
2942 else if (kVCDarkReboot & vc_progress_options.options) delay = 120;
2943 else delay = vc_acquire_delay;
2944
2945 if (kVCDarkBackground & vc_progress_options.options) vc_progress_white = TRUE;
2946 else if (kVCLightBackground & vc_progress_options.options) vc_progress_white = FALSE;
2947
2948 #if !defined(XNU_TARGET_OS_BRIDGE)
2949 vc_progress_set( graphics_now, delay );
2950 #endif /* !defined(XNU_TARGET_OS_BRIDGE) */
2951 gc_enable( !graphics_now );
2952 gc_acquired = TRUE;
2953 gc_desire_text = FALSE;
2954 break;
2955
2956 case kPEDisableScreen:
2957 if (gc_acquired)
2958 {
2959 gc_pause( TRUE, graphics_now );
2960 }
2961 break;
2962
2963 case kPEEnableScreen:
2964 if (gc_acquired)
2965 {
2966 gc_pause( FALSE, graphics_now );
2967 }
2968 break;
2969
2970 case kPETextScreen:
2971 if ( console_is_serial() ) break;
2972
2973 if ( gc_acquired == FALSE )
2974 {
2975 gc_desire_text = TRUE;
2976 break;
2977 }
2978 if ( gc_graphics_boot == FALSE ) break;
2979
2980 vc_progress_set( FALSE, 0 );
2981 #if !CONFIG_EMBEDDED
2982 vc_enable_progressmeter( FALSE );
2983 #endif
2984 gc_enable( TRUE );
2985 break;
2986
2987 case kPEReleaseScreen:
2988 gc_acquired = FALSE;
2989 gc_desire_text = FALSE;
2990 gc_enable( FALSE );
2991 if ( gc_graphics_boot == FALSE ) break;
2992
2993 vc_progress_set( FALSE, 0 );
2994 vc_acquire_delay = kProgressReacquireDelay;
2995 vc_progress_white = TRUE;
2996 #if !CONFIG_EMBEDDED
2997 vc_enable_progressmeter(FALSE);
2998 vc_progress_withmeter &= ~1;
2999 #endif
3000 vc_clut8 = NULL;
3001 break;
3002
3003
3004 #if !CONFIG_EMBEDDED
3005 case kPERefreshBootGraphics:
3006 {
3007 spl_t s;
3008 boolean_t save;
3009
3010 if (kBootArgsFlagBlack & ((boot_args *) PE_state.bootArgs)->flags) break;
3011
3012 save = vc_progress_white;
3013 vc_progress_white = (0 != (kBootArgsFlagBlackBg & ((boot_args *) PE_state.bootArgs)->flags));
3014
3015 internal_enable_progressmeter(kProgressMeterKernel);
3016
3017 s = splhigh();
3018 simple_lock(&vc_progress_lock);
3019
3020 vc_progressmeter_drawn = 0;
3021 internal_set_progressmeter(vc_progressmeter_range(vc_progressmeter_count >> 13));
3022
3023 simple_unlock(&vc_progress_lock);
3024 splx(s);
3025
3026 internal_enable_progressmeter(kProgressMeterOff);
3027 vc_progress_white = save;
3028 }
3029 #endif
3030 }
3031 }
3032
3033 void vcattach(void); /* XXX gcc 4 warning cleanup */
3034
3035 void
3036 vcattach(void)
3037 {
3038 vm_initialized = TRUE;
3039
3040 #if !CONFIG_EMBEDDED
3041 const boot_args * bootargs = (typeof(bootargs)) PE_state.bootArgs;
3042
3043 vc_progress_white = (0 != ((kBootArgsFlagBlackBg | kBootArgsFlagLoginUI)
3044 & bootargs->flags));
3045 PE_parse_boot_argn("meter", &vc_progress_withmeter, sizeof(vc_progress_withmeter));
3046
3047 if (kBootArgsFlagInstallUI & bootargs->flags)
3048 {
3049 vc_progress_meter_start = (bootargs->bootProgressMeterStart * kProgressMeterMax) / 65535;
3050 vc_progress_meter_end = (bootargs->bootProgressMeterEnd * kProgressMeterMax) / 65535;
3051 }
3052 else
3053 {
3054 vc_progress_meter_start = 0;
3055 vc_progress_meter_end = kProgressMeterMax;
3056 }
3057 #endif
3058 simple_lock_init(&vc_progress_lock, 0);
3059
3060 if ( gc_graphics_boot == FALSE )
3061 {
3062 long index;
3063
3064 if ( gc_acquired )
3065 {
3066 initialize_screen(NULL, kPEReleaseScreen);
3067 }
3068
3069 initialize_screen(NULL, kPEAcquireScreen);
3070
3071 for ( index = 0 ; index < msgbufp->msg_bufx ; index++ )
3072 {
3073 if (msgbufp->msg_bufc[index] == '\0') {
3074 continue;
3075 }
3076
3077 vcputc( 0, 0, msgbufp->msg_bufc[index] );
3078
3079 if ( msgbufp->msg_bufc[index] == '\n' )
3080 {
3081 vcputc( 0, 0,'\r' );
3082 }
3083 }
3084 }
3085 }
3086
3087 #if !CONFIG_EMBEDDED
3088
3089 // redraw progress meter between pixels x1, x2, position at x3
3090 static void
3091 vc_draw_progress_meter(unsigned int flags, int x1, int x2, int x3)
3092 {
3093 const unsigned char * data;
3094 int x, w;
3095 int ox, oy;
3096 int endCapPos;
3097 int onoff;
3098 // 1 rounded fill, 0 square end
3099 int style = (0 == (2 & vc_progress_withmeter));
3100
3101 ox = ((vinfo.v_width - (kProgressBarWidth * vc_uiscale)) / 2);
3102 oy = vinfo.v_height - (vinfo.v_height / 3) - ((kProgressBarHeight * vc_uiscale) / 2);
3103
3104 if (kDataBack == flags)
3105 {
3106 // restore back bits
3107 vc_blit_rect(ox + x1, oy, x1,
3108 x2, (kProgressBarHeight * vc_uiscale), 0, (kProgressBarWidth * vc_uiscale),
3109 NULL, vc_progressmeter_backbuffer, flags);
3110 return;
3111 }
3112
3113 for (x = x1; x < x2; x += w)
3114 {
3115 onoff = (x < x3);
3116 endCapPos = ((style && onoff) ? x3 : (kProgressBarWidth * vc_uiscale));
3117 if (x < (kProgressBarCapWidth * vc_uiscale))
3118 {
3119 if (x2 < (kProgressBarCapWidth * vc_uiscale))
3120 w = x2 - x;
3121 else
3122 w = (kProgressBarCapWidth * vc_uiscale) - x;
3123 data = progressmeter_leftcap[vc_uiscale >= 2][onoff];
3124 data += x;
3125 vc_blit_rect(ox + x, oy, x, w,
3126 (kProgressBarHeight * vc_uiscale),
3127 (kProgressBarCapWidth * vc_uiscale),
3128 (kProgressBarWidth * vc_uiscale),
3129 data, vc_progressmeter_backbuffer, flags);
3130 }
3131 else if (x < (endCapPos - (kProgressBarCapWidth * vc_uiscale)))
3132 {
3133 if (x2 < (endCapPos - (kProgressBarCapWidth * vc_uiscale)))
3134 w = x2 - x;
3135 else
3136 w = (endCapPos - (kProgressBarCapWidth * vc_uiscale)) - x;
3137 data = progressmeter_middle[vc_uiscale >= 2][onoff];
3138 vc_blit_rect(ox + x, oy, x, w,
3139 (kProgressBarHeight * vc_uiscale),
3140 1,
3141 (kProgressBarWidth * vc_uiscale),
3142 data, vc_progressmeter_backbuffer, flags);
3143 }
3144 else
3145 {
3146 w = endCapPos - x;
3147 data = progressmeter_rightcap[vc_uiscale >= 2][onoff];
3148 data += x - (endCapPos - (kProgressBarCapWidth * vc_uiscale));
3149 vc_blit_rect(ox + x, oy, x, w,
3150 (kProgressBarHeight * vc_uiscale),
3151 (kProgressBarCapWidth * vc_uiscale),
3152 (kProgressBarWidth * vc_uiscale),
3153 data, vc_progressmeter_backbuffer, flags);
3154 }
3155 }
3156 }
3157
3158 extern void IORecordProgressBackbuffer(void * buffer, size_t size, uint32_t theme);
3159
3160 static void
3161 internal_enable_progressmeter(int new_value)
3162 {
3163 spl_t s;
3164 void * new_buffer;
3165 boolean_t stashBackbuffer;
3166
3167 stashBackbuffer = FALSE;
3168 new_buffer = NULL;
3169 if (new_value)
3170 {
3171 new_buffer = kalloc((kProgressBarWidth * vc_uiscale)
3172 * (kProgressBarHeight * vc_uiscale) * sizeof(int));
3173 }
3174
3175 s = splhigh();
3176 simple_lock(&vc_progress_lock);
3177
3178 if (kProgressMeterUser == new_value)
3179 {
3180 if (gc_enabled || !gc_acquired || !gc_graphics_boot
3181 || (kProgressMeterKernel == vc_progressmeter_enable)) new_value = vc_progressmeter_enable;
3182 }
3183
3184 if (new_value != vc_progressmeter_enable)
3185 {
3186 if (new_value)
3187 {
3188 if (kProgressMeterOff == vc_progressmeter_enable)
3189 {
3190 vc_progressmeter_backbuffer = new_buffer;
3191 vc_draw_progress_meter(kDataAlpha | kSave, 0, (kProgressBarWidth * vc_uiscale), 0);
3192 new_buffer = NULL;
3193 vc_progressmeter_drawn = 0;
3194 }
3195 vc_progressmeter_enable = new_value;
3196 }
3197 else if (vc_progressmeter_backbuffer)
3198 {
3199 if (kProgressMeterUser == vc_progressmeter_enable)
3200 {
3201 vc_draw_progress_meter(kDataBack, 0, (kProgressBarWidth * vc_uiscale), vc_progressmeter_drawn);
3202 }
3203 else stashBackbuffer = TRUE;
3204 new_buffer = vc_progressmeter_backbuffer;
3205 vc_progressmeter_backbuffer = NULL;
3206 vc_progressmeter_enable = FALSE;
3207 }
3208 }
3209
3210 simple_unlock(&vc_progress_lock);
3211 splx(s);
3212
3213 if (new_buffer)
3214 {
3215 if (stashBackbuffer) IORecordProgressBackbuffer(new_buffer,
3216 (kProgressBarWidth * vc_uiscale)
3217 * (kProgressBarHeight * vc_uiscale)
3218 * sizeof(int),
3219 vc_progress_white);
3220 kfree(new_buffer, (kProgressBarWidth * vc_uiscale)
3221 * (kProgressBarHeight * vc_uiscale) * sizeof(int));
3222 }
3223 }
3224
3225 static void
3226 internal_set_progressmeter(int new_value)
3227 {
3228 int x1, x3;
3229 int capRedraw;
3230 // 1 rounded fill, 0 square end
3231 int style = (0 == (2 & vc_progress_withmeter));
3232
3233 if ((new_value < 0) || (new_value > kProgressMeterMax)) return;
3234
3235 if (vc_progressmeter_enable)
3236 {
3237 vc_progressmeter_value = new_value;
3238
3239 capRedraw = (style ? (kProgressBarCapWidth * vc_uiscale) : 0);
3240 x3 = (((kProgressBarWidth * vc_uiscale) - 2 * capRedraw) * vc_progressmeter_value) / kProgressMeterMax;
3241 x3 += (2 * capRedraw);
3242
3243 if (x3 > vc_progressmeter_drawn)
3244 {
3245 x1 = capRedraw;
3246 if (x1 > vc_progressmeter_drawn) x1 = vc_progressmeter_drawn;
3247 vc_draw_progress_meter(kDataAlpha, vc_progressmeter_drawn - x1, x3, x3);
3248 }
3249 else
3250 {
3251 vc_draw_progress_meter(kDataAlpha, x3 - capRedraw, vc_progressmeter_drawn, x3);
3252 }
3253 vc_progressmeter_drawn = x3;
3254 }
3255 }
3256
3257 void
3258 vc_enable_progressmeter(int new_value)
3259 {
3260 if (kProgressMeterKernel == vc_progressmeter_enable)
3261 {
3262 vc_progressmeter_hold = new_value;
3263 }
3264 else
3265 {
3266 internal_enable_progressmeter(new_value ? kProgressMeterUser : kProgressMeterOff);
3267 }
3268 }
3269
3270 void
3271 vc_set_progressmeter(int new_value)
3272 {
3273 spl_t s;
3274
3275 s = splhigh();
3276 simple_lock(&vc_progress_lock);
3277
3278 if (vc_progressmeter_enable && (kProgressMeterKernel != vc_progressmeter_enable))
3279 {
3280 internal_set_progressmeter((new_value * kProgressMeterMax) / 100);
3281 }
3282
3283 simple_unlock(&vc_progress_lock);
3284 splx(s);
3285 }
3286
3287 #endif /* !CONFIG_EMBEDDED */
3288
3289
3290
mirror of XNU