2 * sisusb - usb kernel driver for SiS315(E) based USB2VGA dongles
4 * VGA text mode console part
6 * Copyright (C) 2005 by Thomas Winischhofer, Vienna, Austria
8 * If distributed as part of the Linux kernel, this code is licensed under the
11 * Otherwise, the following license terms apply:
13 * * Redistribution and use in source and binary forms, with or without
14 * * modification, are permitted provided that the following conditions
16 * * 1) Redistributions of source code must retain the above copyright
17 * * notice, this list of conditions and the following disclaimer.
18 * * 2) Redistributions in binary form must reproduce the above copyright
19 * * notice, this list of conditions and the following disclaimer in the
20 * * documentation and/or other materials provided with the distribution.
21 * * 3) The name of the author may not be used to endorse or promote products
22 * * derived from this software without specific psisusbr written permission.
24 * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESSED OR
25 * * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
26 * * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
27 * * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
28 * * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
29 * * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
30 * * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
31 * * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
32 * * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
33 * * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
35 * Author: Thomas Winischhofer <thomas@winischhofer.net>
37 * Portions based on vgacon.c which are
38 * Created 28 Sep 1997 by Geert Uytterhoeven
39 * Rewritten by Martin Mares <mj@ucw.cz>, July 1998
40 * based on code Copyright (C) 1991, 1992 Linus Torvalds
43 * A note on using in_atomic() in here: We can't handle console
44 * calls from non-schedulable context due to our USB-dependend
45 * nature. For now, this driver just ignores any calls if it
50 #include <linux/mutex.h>
51 #include <linux/module.h>
52 #include <linux/kernel.h>
53 #include <linux/signal.h>
55 #include <linux/usb.h>
56 #include <linux/tty.h>
57 #include <linux/console.h>
58 #include <linux/string.h>
60 #include <linux/init.h>
61 #include <linux/vt_kern.h>
62 #include <linux/selection.h>
63 #include <linux/spinlock.h>
64 #include <linux/kref.h>
65 #include <linux/ioport.h>
66 #include <linux/interrupt.h>
67 #include <linux/vmalloc.h>
70 #include "sisusb_init.h"
72 #ifdef INCL_SISUSB_CON
74 #define sisusbcon_writew(val, addr) (*(addr) = (val))
75 #define sisusbcon_readw(addr) (*(addr))
76 #define sisusbcon_memmovew(d, s, c) memmove(d, s, c)
77 #define sisusbcon_memcpyw(d, s, c) memcpy(d, s, c)
79 /* vc_data -> sisusb conversion table */
80 static struct sisusb_usb_data
*mysisusbs
[MAX_NR_CONSOLES
];
82 /* Forward declaration */
83 static const struct consw sisusb_con
;
86 sisusbcon_memsetw(u16
*s
, u16 c
, unsigned int count
)
90 sisusbcon_writew(c
, s
++);
94 sisusb_initialize(struct sisusb_usb_data
*sisusb
)
96 /* Reset cursor and start address */
97 if (sisusb_setidxreg(sisusb
, SISCR
, 0x0c, 0x00))
99 if (sisusb_setidxreg(sisusb
, SISCR
, 0x0d, 0x00))
101 if (sisusb_setidxreg(sisusb
, SISCR
, 0x0e, 0x00))
103 sisusb_setidxreg(sisusb
, SISCR
, 0x0f, 0x00);
107 sisusbcon_set_start_address(struct sisusb_usb_data
*sisusb
, struct vc_data
*c
)
109 sisusb
->cur_start_addr
= (c
->vc_visible_origin
- sisusb
->scrbuf
) / 2;
111 sisusb_setidxreg(sisusb
, SISCR
, 0x0c, (sisusb
->cur_start_addr
>> 8));
112 sisusb_setidxreg(sisusb
, SISCR
, 0x0d, (sisusb
->cur_start_addr
& 0xff));
116 sisusb_set_cursor(struct sisusb_usb_data
*sisusb
, unsigned int location
)
118 if (sisusb
->sisusb_cursor_loc
== location
)
121 sisusb
->sisusb_cursor_loc
= location
;
124 if ((location
& 0x0007) == 0x0007) {
125 sisusb
->bad_cursor_pos
= 1;
127 if (sisusb_setidxregandor(sisusb
, SISCR
, 0x0b, 0x1f, 0x20))
129 } else if (sisusb
->bad_cursor_pos
) {
130 if (sisusb_setidxregand(sisusb
, SISCR
, 0x0b, 0x1f))
132 sisusb
->bad_cursor_pos
= 0;
135 if (sisusb_setidxreg(sisusb
, SISCR
, 0x0e, (location
>> 8)))
137 sisusb_setidxreg(sisusb
, SISCR
, 0x0f, (location
& 0xff));
140 static inline struct sisusb_usb_data
*
141 sisusb_get_sisusb(unsigned short console
)
143 return mysisusbs
[console
];
147 sisusb_sisusb_valid(struct sisusb_usb_data
*sisusb
)
149 if (!sisusb
->present
|| !sisusb
->ready
|| !sisusb
->sisusb_dev
)
155 static struct sisusb_usb_data
*
156 sisusb_get_sisusb_lock_and_check(unsigned short console
)
158 struct sisusb_usb_data
*sisusb
;
160 /* We can't handle console calls in non-schedulable
161 * context due to our locks and the USB transport.
162 * So we simply ignore them. This should only affect
163 * some calls to printk.
168 if (!(sisusb
= sisusb_get_sisusb(console
)))
171 mutex_lock(&sisusb
->lock
);
173 if (!sisusb_sisusb_valid(sisusb
) ||
174 !sisusb
->havethisconsole
[console
]) {
175 mutex_unlock(&sisusb
->lock
);
183 sisusb_is_inactive(struct vc_data
*c
, struct sisusb_usb_data
*sisusb
)
185 if (sisusb
->is_gfx
||
186 sisusb
->textmodedestroyed
||
187 c
->vc_mode
!= KD_TEXT
)
193 /* con_startup console interface routine */
195 sisusbcon_startup(void)
200 /* con_init console interface routine */
202 sisusbcon_init(struct vc_data
*c
, int init
)
204 struct sisusb_usb_data
*sisusb
;
207 /* This is called by take_over_console(),
208 * ie by us/under our control. It is
209 * only called after text mode and fonts
210 * are set up/restored.
213 if (!(sisusb
= sisusb_get_sisusb(c
->vc_num
)))
216 mutex_lock(&sisusb
->lock
);
218 if (!sisusb_sisusb_valid(sisusb
)) {
219 mutex_unlock(&sisusb
->lock
);
223 c
->vc_can_do_color
= 1;
225 c
->vc_complement_mask
= 0x7700;
227 c
->vc_hi_font_mask
= sisusb
->current_font_512
? 0x0800 : 0;
229 sisusb
->haveconsole
= 1;
231 sisusb
->havethisconsole
[c
->vc_num
] = 1;
233 /* We only support 640x400 */
234 c
->vc_scan_lines
= 400;
236 c
->vc_font
.height
= sisusb
->current_font_height
;
238 /* We only support width = 8 */
240 rows
= c
->vc_scan_lines
/ c
->vc_font
.height
;
242 /* Increment usage count for our sisusb.
243 * Doing so saves us from upping/downing
244 * the disconnect semaphore; we can't
245 * lose our sisusb until this is undone
246 * in con_deinit. For all other console
247 * interface functions, it suffices to
248 * use sisusb->lock and do a quick check
249 * of sisusb for device disconnection.
251 kref_get(&sisusb
->kref
);
253 if (!*c
->vc_uni_pagedir_loc
)
254 con_set_default_unimap(c
);
256 mutex_unlock(&sisusb
->lock
);
262 vc_resize(c
, cols
, rows
);
265 /* con_deinit console interface routine */
267 sisusbcon_deinit(struct vc_data
*c
)
269 struct sisusb_usb_data
*sisusb
;
272 /* This is called by take_over_console()
273 * and others, ie not under our control.
276 if (!(sisusb
= sisusb_get_sisusb(c
->vc_num
)))
279 mutex_lock(&sisusb
->lock
);
281 /* Clear ourselves in mysisusbs */
282 mysisusbs
[c
->vc_num
] = NULL
;
284 sisusb
->havethisconsole
[c
->vc_num
] = 0;
286 /* Free our font buffer if all consoles are gone */
287 if (sisusb
->font_backup
) {
288 for(i
= 0; i
< MAX_NR_CONSOLES
; i
++) {
289 if (sisusb
->havethisconsole
[c
->vc_num
])
292 if (i
== MAX_NR_CONSOLES
) {
293 vfree(sisusb
->font_backup
);
294 sisusb
->font_backup
= NULL
;
298 mutex_unlock(&sisusb
->lock
);
300 /* decrement the usage count on our sisusb */
301 kref_put(&sisusb
->kref
, sisusb_delete
);
304 /* interface routine */
306 sisusbcon_build_attr(struct vc_data
*c
, u8 color
, u8 intensity
,
307 u8 blink
, u8 underline
, u8 reverse
, u8 unused
)
312 attr
= (attr
& 0xf0) | c
->vc_ulcolor
;
313 else if (intensity
== 0)
314 attr
= (attr
& 0xf0) | c
->vc_halfcolor
;
317 attr
= ((attr
) & 0x88) |
319 ((attr
) << 4)) & 0x77);
330 /* Interface routine */
332 sisusbcon_invert_region(struct vc_data
*vc
, u16
*p
, int count
)
334 /* Invert a region. This is called with a pointer
335 * to the console's internal screen buffer. So we
336 * simply do the inversion there and rely on
337 * a call to putc(s) to update the real screen.
341 u16 a
= sisusbcon_readw(p
);
344 (((a
) & 0x7000) >> 4) |
345 (((a
) & 0x0700) << 4);
347 sisusbcon_writew(a
, p
++);
351 #define SISUSB_VADDR(x,y) \
352 ((u16 *)c->vc_origin + \
353 (y) * sisusb->sisusb_num_columns + \
356 #define SISUSB_HADDR(x,y) \
357 ((u16 *)(sisusb->vrambase + (c->vc_origin - sisusb->scrbuf)) + \
358 (y) * sisusb->sisusb_num_columns + \
361 /* Interface routine */
363 sisusbcon_putc(struct vc_data
*c
, int ch
, int y
, int x
)
365 struct sisusb_usb_data
*sisusb
;
368 if (!(sisusb
= sisusb_get_sisusb_lock_and_check(c
->vc_num
)))
371 /* sisusb->lock is down */
372 if (sisusb_is_inactive(c
, sisusb
)) {
373 mutex_unlock(&sisusb
->lock
);
378 sisusb_copy_memory(sisusb
, (char *)SISUSB_VADDR(x
, y
),
379 (long)SISUSB_HADDR(x
, y
), 2, &written
);
381 mutex_unlock(&sisusb
->lock
);
384 /* Interface routine */
386 sisusbcon_putcs(struct vc_data
*c
, const unsigned short *s
,
387 int count
, int y
, int x
)
389 struct sisusb_usb_data
*sisusb
;
394 if (!(sisusb
= sisusb_get_sisusb_lock_and_check(c
->vc_num
)))
397 /* sisusb->lock is down */
399 /* Need to put the characters into the buffer ourselves,
400 * because the vt does this AFTER calling us.
403 dest
= SISUSB_VADDR(x
, y
);
405 for (i
= count
; i
> 0; i
--)
406 sisusbcon_writew(sisusbcon_readw(s
++), dest
++);
408 if (sisusb_is_inactive(c
, sisusb
)) {
409 mutex_unlock(&sisusb
->lock
);
413 sisusb_copy_memory(sisusb
, (char *)SISUSB_VADDR(x
, y
),
414 (long)SISUSB_HADDR(x
, y
), count
* 2, &written
);
416 mutex_unlock(&sisusb
->lock
);
419 /* Interface routine */
421 sisusbcon_clear(struct vc_data
*c
, int y
, int x
, int height
, int width
)
423 struct sisusb_usb_data
*sisusb
;
424 u16 eattr
= c
->vc_video_erase_char
;
429 if (width
<= 0 || height
<= 0)
432 if (!(sisusb
= sisusb_get_sisusb_lock_and_check(c
->vc_num
)))
435 /* sisusb->lock is down */
437 /* Need to clear buffer ourselves, because the vt does
438 * this AFTER calling us.
441 dest
= SISUSB_VADDR(x
, y
);
443 cols
= sisusb
->sisusb_num_columns
;
448 if (x
== 0 && width
>= c
->vc_cols
) {
450 sisusbcon_memsetw(dest
, eattr
, height
* cols
* 2);
454 for (i
= height
; i
> 0; i
--, dest
+= cols
)
455 sisusbcon_memsetw(dest
, eattr
, width
* 2);
459 if (sisusb_is_inactive(c
, sisusb
)) {
460 mutex_unlock(&sisusb
->lock
);
464 length
= ((height
* cols
) - x
- (cols
- width
- x
)) * 2;
467 sisusb_copy_memory(sisusb
, (unsigned char *)SISUSB_VADDR(x
, y
),
468 (long)SISUSB_HADDR(x
, y
), length
, &written
);
470 mutex_unlock(&sisusb
->lock
);
473 /* Interface routine */
475 sisusbcon_bmove(struct vc_data
*c
, int sy
, int sx
,
476 int dy
, int dx
, int height
, int width
)
478 struct sisusb_usb_data
*sisusb
;
482 if (width
<= 0 || height
<= 0)
485 if (!(sisusb
= sisusb_get_sisusb_lock_and_check(c
->vc_num
)))
488 /* sisusb->lock is down */
490 cols
= sisusb
->sisusb_num_columns
;
492 if (sisusb_is_inactive(c
, sisusb
)) {
493 mutex_unlock(&sisusb
->lock
);
497 length
= ((height
* cols
) - dx
- (cols
- width
- dx
)) * 2;
500 sisusb_copy_memory(sisusb
, (unsigned char *)SISUSB_VADDR(dx
, dy
),
501 (long)SISUSB_HADDR(dx
, dy
), length
, &written
);
503 mutex_unlock(&sisusb
->lock
);
506 /* interface routine */
508 sisusbcon_switch(struct vc_data
*c
)
510 struct sisusb_usb_data
*sisusb
;
514 /* Returnvalue 0 means we have fully restored screen,
515 * and vt doesn't need to call do_update_region().
516 * Returnvalue != 0 naturally means the opposite.
519 if (!(sisusb
= sisusb_get_sisusb_lock_and_check(c
->vc_num
)))
522 /* sisusb->lock is down */
524 /* Don't write to screen if in gfx mode */
525 if (sisusb_is_inactive(c
, sisusb
)) {
526 mutex_unlock(&sisusb
->lock
);
530 /* That really should not happen. It would mean we are
531 * being called while the vc is using its private buffer
534 if (c
->vc_origin
== (unsigned long)c
->vc_screenbuf
) {
535 mutex_unlock(&sisusb
->lock
);
536 dev_dbg(&sisusb
->sisusb_dev
->dev
, "ASSERT ORIGIN != SCREENBUF!\n");
540 /* Check that we don't copy too much */
541 length
= min((int)c
->vc_screenbuf_size
,
542 (int)(sisusb
->scrbuf
+ sisusb
->scrbuf_size
- c
->vc_origin
));
544 /* Restore the screen contents */
545 sisusbcon_memcpyw((u16
*)c
->vc_origin
, (u16
*)c
->vc_screenbuf
,
548 sisusb_copy_memory(sisusb
, (unsigned char *)c
->vc_origin
,
549 (long)SISUSB_HADDR(0, 0),
552 mutex_unlock(&sisusb
->lock
);
557 /* interface routine */
559 sisusbcon_save_screen(struct vc_data
*c
)
561 struct sisusb_usb_data
*sisusb
;
564 /* Save the current screen contents to vc's private
568 if (!(sisusb
= sisusb_get_sisusb_lock_and_check(c
->vc_num
)))
571 /* sisusb->lock is down */
573 if (sisusb_is_inactive(c
, sisusb
)) {
574 mutex_unlock(&sisusb
->lock
);
578 /* Check that we don't copy too much */
579 length
= min((int)c
->vc_screenbuf_size
,
580 (int)(sisusb
->scrbuf
+ sisusb
->scrbuf_size
- c
->vc_origin
));
582 /* Save the screen contents to vc's private buffer */
583 sisusbcon_memcpyw((u16
*)c
->vc_screenbuf
, (u16
*)c
->vc_origin
,
586 mutex_unlock(&sisusb
->lock
);
589 /* interface routine */
591 sisusbcon_set_palette(struct vc_data
*c
, unsigned char *table
)
593 struct sisusb_usb_data
*sisusb
;
596 /* Return value not used by vt */
598 if (!CON_IS_VISIBLE(c
))
601 if (!(sisusb
= sisusb_get_sisusb_lock_and_check(c
->vc_num
)))
604 /* sisusb->lock is down */
606 if (sisusb_is_inactive(c
, sisusb
)) {
607 mutex_unlock(&sisusb
->lock
);
611 for (i
= j
= 0; i
< 16; i
++) {
612 if (sisusb_setreg(sisusb
, SISCOLIDX
, table
[i
]))
614 if (sisusb_setreg(sisusb
, SISCOLDATA
, c
->vc_palette
[j
++] >> 2))
616 if (sisusb_setreg(sisusb
, SISCOLDATA
, c
->vc_palette
[j
++] >> 2))
618 if (sisusb_setreg(sisusb
, SISCOLDATA
, c
->vc_palette
[j
++] >> 2))
622 mutex_unlock(&sisusb
->lock
);
627 /* interface routine */
629 sisusbcon_blank(struct vc_data
*c
, int blank
, int mode_switch
)
631 struct sisusb_usb_data
*sisusb
;
632 u8 sr1
, cr17
, pmreg
, cr63
;
636 if (!(sisusb
= sisusb_get_sisusb_lock_and_check(c
->vc_num
)))
639 /* sisusb->lock is down */
642 sisusb
->is_gfx
= blank
? 1 : 0;
644 if (sisusb_is_inactive(c
, sisusb
)) {
645 mutex_unlock(&sisusb
->lock
);
651 case 1: /* Normal blanking: Clear screen */
653 sisusbcon_memsetw((u16
*)c
->vc_origin
,
654 c
->vc_video_erase_char
,
655 c
->vc_screenbuf_size
);
656 sisusb_copy_memory(sisusb
,
657 (unsigned char *)c
->vc_origin
,
658 (u32
)(sisusb
->vrambase
+
659 (c
->vc_origin
- sisusb
->scrbuf
)),
660 c
->vc_screenbuf_size
, &written
);
661 sisusb
->con_blanked
= 1;
665 default: /* VESA blanking */
667 case 0: /* Unblank */
673 sisusb
->con_blanked
= 0;
675 case VESA_VSYNC_SUSPEND
+ 1:
681 case VESA_HSYNC_SUSPEND
+ 1:
687 case VESA_POWERDOWN
+ 1:
694 mutex_unlock(&sisusb
->lock
);
698 sisusb_setidxregandor(sisusb
, SISSR
, 0x01, ~0x20, sr1
);
699 sisusb_setidxregandor(sisusb
, SISCR
, 0x17, 0x7f, cr17
);
700 sisusb_setidxregandor(sisusb
, SISSR
, 0x1f, 0x3f, pmreg
);
701 sisusb_setidxregandor(sisusb
, SISCR
, 0x63, 0xbf, cr63
);
705 mutex_unlock(&sisusb
->lock
);
710 /* interface routine */
712 sisusbcon_scrolldelta(struct vc_data
*c
, int lines
)
714 struct sisusb_usb_data
*sisusb
;
715 int margin
= c
->vc_size_row
* 4;
718 /* The return value does not seem to be used */
720 if (!(sisusb
= sisusb_get_sisusb_lock_and_check(c
->vc_num
)))
723 /* sisusb->lock is down */
725 if (sisusb_is_inactive(c
, sisusb
)) {
726 mutex_unlock(&sisusb
->lock
);
730 if (!lines
) /* Turn scrollback off */
731 c
->vc_visible_origin
= c
->vc_origin
;
734 if (sisusb
->con_rolled_over
>
735 (c
->vc_scr_end
- sisusb
->scrbuf
) + margin
) {
737 ul
= c
->vc_scr_end
- sisusb
->scrbuf
;
738 we
= sisusb
->con_rolled_over
+ c
->vc_size_row
;
743 we
= sisusb
->scrbuf_size
;
747 p
= (c
->vc_visible_origin
- sisusb
->scrbuf
- ul
+ we
) % we
+
748 lines
* c
->vc_size_row
;
750 st
= (c
->vc_origin
- sisusb
->scrbuf
- ul
+ we
) % we
;
761 c
->vc_visible_origin
= sisusb
->scrbuf
+ (p
+ ul
) % we
;
764 sisusbcon_set_start_address(sisusb
, c
);
766 mutex_unlock(&sisusb
->lock
);
771 /* Interface routine */
773 sisusbcon_cursor(struct vc_data
*c
, int mode
)
775 struct sisusb_usb_data
*sisusb
;
776 int from
, to
, baseline
;
778 if (!(sisusb
= sisusb_get_sisusb_lock_and_check(c
->vc_num
)))
781 /* sisusb->lock is down */
783 if (sisusb_is_inactive(c
, sisusb
)) {
784 mutex_unlock(&sisusb
->lock
);
788 if (c
->vc_origin
!= c
->vc_visible_origin
) {
789 c
->vc_visible_origin
= c
->vc_origin
;
790 sisusbcon_set_start_address(sisusb
, c
);
793 if (mode
== CM_ERASE
) {
794 sisusb_setidxregor(sisusb
, SISCR
, 0x0a, 0x20);
795 sisusb
->sisusb_cursor_size_to
= -1;
796 mutex_unlock(&sisusb
->lock
);
800 sisusb_set_cursor(sisusb
, (c
->vc_pos
- sisusb
->scrbuf
) / 2);
802 baseline
= c
->vc_font
.height
- (c
->vc_font
.height
< 10 ? 1 : 2);
804 switch (c
->vc_cursor_type
& 0x0f) {
805 case CUR_BLOCK
: from
= 1;
806 to
= c
->vc_font
.height
;
808 case CUR_TWO_THIRDS
: from
= c
->vc_font
.height
/ 3;
811 case CUR_LOWER_HALF
: from
= c
->vc_font
.height
/ 2;
814 case CUR_LOWER_THIRD
: from
= (c
->vc_font
.height
* 2) / 3;
817 case CUR_NONE
: from
= 31;
821 case CUR_UNDERLINE
: from
= baseline
- 1;
826 if (sisusb
->sisusb_cursor_size_from
!= from
||
827 sisusb
->sisusb_cursor_size_to
!= to
) {
829 sisusb_setidxreg(sisusb
, SISCR
, 0x0a, from
);
830 sisusb_setidxregandor(sisusb
, SISCR
, 0x0b, 0xe0, to
);
832 sisusb
->sisusb_cursor_size_from
= from
;
833 sisusb
->sisusb_cursor_size_to
= to
;
836 mutex_unlock(&sisusb
->lock
);
840 sisusbcon_scroll_area(struct vc_data
*c
, struct sisusb_usb_data
*sisusb
,
841 int t
, int b
, int dir
, int lines
)
843 int cols
= sisusb
->sisusb_num_columns
;
844 int length
= ((b
- t
) * cols
) * 2;
845 u16 eattr
= c
->vc_video_erase_char
;
848 /* sisusb->lock is down */
850 /* Scroll an area which does not match the
851 * visible screen's dimensions. This needs
852 * to be done separately, as it does not
853 * use hardware panning.
859 sisusbcon_memmovew(SISUSB_VADDR(0, t
),
860 SISUSB_VADDR(0, t
+ lines
),
861 (b
- t
- lines
) * cols
* 2);
862 sisusbcon_memsetw(SISUSB_VADDR(0, b
- lines
), eattr
,
867 sisusbcon_memmovew(SISUSB_VADDR(0, t
+ lines
),
869 (b
- t
- lines
) * cols
* 2);
870 sisusbcon_memsetw(SISUSB_VADDR(0, t
), eattr
,
875 sisusb_copy_memory(sisusb
, (char *)SISUSB_VADDR(0, t
),
876 (long)SISUSB_HADDR(0, t
), length
, &written
);
878 mutex_unlock(&sisusb
->lock
);
883 /* Interface routine */
885 sisusbcon_scroll(struct vc_data
*c
, int t
, int b
, int dir
, int lines
)
887 struct sisusb_usb_data
*sisusb
;
888 u16 eattr
= c
->vc_video_erase_char
;
891 unsigned long oldorigin
;
892 unsigned int delta
= lines
* c
->vc_size_row
;
895 /* Returning != 0 means we have done the scrolling successfully.
896 * Returning 0 makes vt do the scrolling on its own.
897 * Note that con_scroll is only called if the console is
898 * visible. In that case, the origin should be our buffer,
899 * not the vt's private one.
905 if (!(sisusb
= sisusb_get_sisusb_lock_and_check(c
->vc_num
)))
908 /* sisusb->lock is down */
910 if (sisusb_is_inactive(c
, sisusb
)) {
911 mutex_unlock(&sisusb
->lock
);
916 if (t
|| b
!= c
->vc_rows
)
917 return sisusbcon_scroll_area(c
, sisusb
, t
, b
, dir
, lines
);
919 if (c
->vc_origin
!= c
->vc_visible_origin
) {
920 c
->vc_visible_origin
= c
->vc_origin
;
921 sisusbcon_set_start_address(sisusb
, c
);
924 /* limit amount to maximum realistic size */
925 if (lines
> c
->vc_rows
)
928 oldorigin
= c
->vc_origin
;
934 if (c
->vc_scr_end
+ delta
>=
935 sisusb
->scrbuf
+ sisusb
->scrbuf_size
) {
936 sisusbcon_memcpyw((u16
*)sisusb
->scrbuf
,
937 (u16
*)(oldorigin
+ delta
),
938 c
->vc_screenbuf_size
- delta
);
939 c
->vc_origin
= sisusb
->scrbuf
;
940 sisusb
->con_rolled_over
= oldorigin
- sisusb
->scrbuf
;
943 c
->vc_origin
+= delta
;
946 (u16
*)(c
->vc_origin
+ c
->vc_screenbuf_size
- delta
),
953 if (oldorigin
- delta
< sisusb
->scrbuf
) {
954 sisusbcon_memmovew((u16
*)(sisusb
->scrbuf
+
955 sisusb
->scrbuf_size
-
956 c
->vc_screenbuf_size
+
959 c
->vc_screenbuf_size
- delta
);
960 c
->vc_origin
= sisusb
->scrbuf
+
961 sisusb
->scrbuf_size
-
962 c
->vc_screenbuf_size
;
963 sisusb
->con_rolled_over
= 0;
966 c
->vc_origin
-= delta
;
968 c
->vc_scr_end
= c
->vc_origin
+ c
->vc_screenbuf_size
;
970 scr_memsetw((u16
*)(c
->vc_origin
), eattr
, delta
);
975 originoffset
= (u32
)(c
->vc_origin
- sisusb
->scrbuf
);
978 sisusb_copy_memory(sisusb
,
979 (char *)c
->vc_origin
,
980 (u32
)(sisusb
->vrambase
+ originoffset
),
981 c
->vc_screenbuf_size
, &written
);
982 else if (dir
== SM_UP
)
983 sisusb_copy_memory(sisusb
,
984 (char *)c
->vc_origin
+ c
->vc_screenbuf_size
- delta
,
985 (u32
)sisusb
->vrambase
+ originoffset
+
986 c
->vc_screenbuf_size
- delta
,
989 sisusb_copy_memory(sisusb
,
990 (char *)c
->vc_origin
,
991 (u32
)(sisusb
->vrambase
+ originoffset
),
994 c
->vc_scr_end
= c
->vc_origin
+ c
->vc_screenbuf_size
;
995 c
->vc_visible_origin
= c
->vc_origin
;
997 sisusbcon_set_start_address(sisusb
, c
);
999 c
->vc_pos
= c
->vc_pos
- oldorigin
+ c
->vc_origin
;
1001 mutex_unlock(&sisusb
->lock
);
1006 /* Interface routine */
1008 sisusbcon_set_origin(struct vc_data
*c
)
1010 struct sisusb_usb_data
*sisusb
;
1012 /* Returning != 0 means we were successful.
1013 * Returning 0 will vt make to use its own
1014 * screenbuffer as the origin.
1017 if (!(sisusb
= sisusb_get_sisusb_lock_and_check(c
->vc_num
)))
1020 /* sisusb->lock is down */
1022 if (sisusb_is_inactive(c
, sisusb
) || sisusb
->con_blanked
) {
1023 mutex_unlock(&sisusb
->lock
);
1027 c
->vc_origin
= c
->vc_visible_origin
= sisusb
->scrbuf
;
1029 sisusbcon_set_start_address(sisusb
, c
);
1031 sisusb
->con_rolled_over
= 0;
1033 mutex_unlock(&sisusb
->lock
);
1038 /* Interface routine */
1040 sisusbcon_resize(struct vc_data
*c
, unsigned int newcols
, unsigned int newrows
,
1043 struct sisusb_usb_data
*sisusb
;
1046 if (!(sisusb
= sisusb_get_sisusb_lock_and_check(c
->vc_num
)))
1049 fh
= sisusb
->current_font_height
;
1051 mutex_unlock(&sisusb
->lock
);
1053 /* We are quite unflexible as regards resizing. The vt code
1054 * handles sizes where the line length isn't equal the pitch
1055 * quite badly. As regards the rows, our panning tricks only
1056 * work well if the number of rows equals the visible number
1060 if (newcols
!= 80 || c
->vc_scan_lines
/ fh
!= newrows
)
1067 sisusbcon_do_font_op(struct sisusb_usb_data
*sisusb
, int set
, int slot
,
1068 u8
*arg
, int cmapsz
, int ch512
, int dorecalc
,
1069 struct vc_data
*c
, int fh
, int uplock
)
1071 int font_select
= 0x00, i
, err
= 0;
1075 /* sisusb->lock is down */
1078 * The default font is kept in slot 0.
1079 * A user font is loaded in slot 2 (256 ch)
1083 if ((slot
!= 0 && slot
!= 2) || !fh
) {
1085 mutex_unlock(&sisusb
->lock
);
1090 sisusb
->font_slot
= slot
;
1092 /* Default font is always 256 */
1096 offset
= 4 * cmapsz
;
1098 font_select
= (slot
== 0) ? 0x00 : (ch512
? 0x0e : 0x0a);
1100 err
|= sisusb_setidxreg(sisusb
, SISSR
, 0x00, 0x01); /* Reset */
1101 err
|= sisusb_setidxreg(sisusb
, SISSR
, 0x02, 0x04); /* Write to plane 2 */
1102 err
|= sisusb_setidxreg(sisusb
, SISSR
, 0x04, 0x07); /* Memory mode a0-bf */
1103 err
|= sisusb_setidxreg(sisusb
, SISSR
, 0x00, 0x03); /* Reset */
1108 err
|= sisusb_setidxreg(sisusb
, SISGR
, 0x04, 0x03); /* Select plane read 2 */
1109 err
|= sisusb_setidxreg(sisusb
, SISGR
, 0x05, 0x00); /* Disable odd/even */
1110 err
|= sisusb_setidxreg(sisusb
, SISGR
, 0x06, 0x00); /* Address range a0-bf */
1117 for (i
= 0; i
< cmapsz
; i
++) {
1118 err
|= sisusb_writeb(sisusb
,
1119 sisusb
->vrambase
+ offset
+ i
,
1125 for (i
= 0; i
< cmapsz
; i
++) {
1126 err
|= sisusb_readb(sisusb
,
1127 sisusb
->vrambase
+ offset
+ i
,
1134 * In 512-character mode, the character map is not contiguous if
1135 * we want to remain EGA compatible -- which we do
1140 for (i
= 0; i
< cmapsz
; i
++) {
1141 err
|= sisusb_writeb(sisusb
,
1142 sisusb
->vrambase
+ offset
+
1149 for (i
= 0; i
< cmapsz
; i
++) {
1150 err
|= sisusb_readb(sisusb
,
1151 sisusb
->vrambase
+ offset
+
1163 err
|= sisusb_setidxreg(sisusb
, SISSR
, 0x00, 0x01); /* Reset */
1164 err
|= sisusb_setidxreg(sisusb
, SISSR
, 0x02, 0x03); /* Write to planes 0+1 */
1165 err
|= sisusb_setidxreg(sisusb
, SISSR
, 0x04, 0x03); /* Memory mode a0-bf */
1167 sisusb_setidxreg(sisusb
, SISSR
, 0x03, font_select
);
1168 err
|= sisusb_setidxreg(sisusb
, SISSR
, 0x00, 0x03); /* Reset end */
1173 err
|= sisusb_setidxreg(sisusb
, SISGR
, 0x04, 0x00); /* Select plane read 0 */
1174 err
|= sisusb_setidxreg(sisusb
, SISGR
, 0x05, 0x10); /* Enable odd/even */
1175 err
|= sisusb_setidxreg(sisusb
, SISGR
, 0x06, 0x06); /* Address range b8-bf */
1180 if ((set
) && (ch512
!= sisusb
->current_font_512
)) {
1182 /* Font is shared among all our consoles.
1183 * And so is the hi_font_mask.
1185 for (i
= 0; i
< MAX_NR_CONSOLES
; i
++) {
1186 struct vc_data
*d
= vc_cons
[i
].d
;
1187 if (d
&& d
->vc_sw
== &sisusb_con
)
1188 d
->vc_hi_font_mask
= ch512
? 0x0800 : 0;
1191 sisusb
->current_font_512
= ch512
;
1193 /* color plane enable register:
1194 256-char: enable intensity bit
1195 512-char: disable intensity bit */
1196 sisusb_getreg(sisusb
, SISINPSTAT
, &dummy
);
1197 sisusb_setreg(sisusb
, SISAR
, 0x12);
1198 sisusb_setreg(sisusb
, SISAR
, ch512
? 0x07 : 0x0f);
1200 sisusb_getreg(sisusb
, SISINPSTAT
, &dummy
);
1201 sisusb_setreg(sisusb
, SISAR
, 0x20);
1202 sisusb_getreg(sisusb
, SISINPSTAT
, &dummy
);
1208 * Adjust the screen to fit a font of a certain height
1211 unsigned char ovr
, vde
, fsr
;
1212 int rows
= 0, maxscan
= 0;
1216 /* Number of video rows */
1217 rows
= c
->vc_scan_lines
/ fh
;
1218 /* Scan lines to actually display-1 */
1219 maxscan
= rows
* fh
- 1;
1221 /*printk(KERN_DEBUG "sisusb recalc rows %d maxscan %d fh %d sl %d\n",
1222 rows, maxscan, fh, c->vc_scan_lines);*/
1224 sisusb_getidxreg(sisusb
, SISCR
, 0x07, &ovr
);
1225 vde
= maxscan
& 0xff;
1226 ovr
= (ovr
& 0xbd) |
1227 ((maxscan
& 0x100) >> 7) |
1228 ((maxscan
& 0x200) >> 3);
1229 sisusb_setidxreg(sisusb
, SISCR
, 0x07, ovr
);
1230 sisusb_setidxreg(sisusb
, SISCR
, 0x12, vde
);
1234 sisusb_getidxreg(sisusb
, SISCR
, 0x09, &fsr
);
1235 fsr
= (fsr
& 0xe0) | (fh
- 1);
1236 sisusb_setidxreg(sisusb
, SISCR
, 0x09, fsr
);
1237 sisusb
->current_font_height
= fh
;
1239 sisusb
->sisusb_cursor_size_from
= -1;
1240 sisusb
->sisusb_cursor_size_to
= -1;
1245 mutex_unlock(&sisusb
->lock
);
1247 if (dorecalc
&& c
) {
1248 int rows
= c
->vc_scan_lines
/ fh
;
1250 /* Now adjust our consoles' size */
1252 for (i
= 0; i
< MAX_NR_CONSOLES
; i
++) {
1253 struct vc_data
*vc
= vc_cons
[i
].d
;
1255 if (vc
&& vc
->vc_sw
== &sisusb_con
) {
1256 if (CON_IS_VISIBLE(vc
)) {
1257 vc
->vc_sw
->con_cursor(vc
, CM_DRAW
);
1259 vc
->vc_font
.height
= fh
;
1260 vc_resize(vc
, 0, rows
);
1269 mutex_unlock(&sisusb
->lock
);
1274 /* Interface routine */
1276 sisusbcon_font_set(struct vc_data
*c
, struct console_font
*font
,
1279 struct sisusb_usb_data
*sisusb
;
1280 unsigned charcount
= font
->charcount
;
1282 if (font
->width
!= 8 || (charcount
!= 256 && charcount
!= 512))
1285 if (!(sisusb
= sisusb_get_sisusb_lock_and_check(c
->vc_num
)))
1288 /* sisusb->lock is down */
1290 /* Save the user-provided font into a buffer. This
1291 * is used for restoring text mode after quitting
1292 * from X and for the con_getfont routine.
1294 if (sisusb
->font_backup
) {
1295 if (sisusb
->font_backup_size
< charcount
) {
1296 vfree(sisusb
->font_backup
);
1297 sisusb
->font_backup
= NULL
;
1301 if (!sisusb
->font_backup
)
1302 sisusb
->font_backup
= vmalloc(charcount
* 32);
1304 if (sisusb
->font_backup
) {
1305 memcpy(sisusb
->font_backup
, font
->data
, charcount
* 32);
1306 sisusb
->font_backup_size
= charcount
;
1307 sisusb
->font_backup_height
= font
->height
;
1308 sisusb
->font_backup_512
= (charcount
== 512) ? 1 : 0;
1311 /* do_font_op ups sisusb->lock */
1313 return sisusbcon_do_font_op(sisusb
, 1, 2, font
->data
,
1314 8192, (charcount
== 512),
1315 (!(flags
& KD_FONT_FLAG_DONT_RECALC
)) ? 1 : 0,
1316 c
, font
->height
, 1);
1319 /* Interface routine */
1321 sisusbcon_font_get(struct vc_data
*c
, struct console_font
*font
)
1323 struct sisusb_usb_data
*sisusb
;
1325 if (!(sisusb
= sisusb_get_sisusb_lock_and_check(c
->vc_num
)))
1328 /* sisusb->lock is down */
1331 font
->height
= c
->vc_font
.height
;
1332 font
->charcount
= 256;
1335 mutex_unlock(&sisusb
->lock
);
1339 if (!sisusb
->font_backup
) {
1340 mutex_unlock(&sisusb
->lock
);
1344 /* Copy 256 chars only, like vgacon */
1345 memcpy(font
->data
, sisusb
->font_backup
, 256 * 32);
1347 mutex_unlock(&sisusb
->lock
);
1353 * The console `switch' structure for the sisusb console
1356 static const struct consw sisusb_con
= {
1357 .owner
= THIS_MODULE
,
1358 .con_startup
= sisusbcon_startup
,
1359 .con_init
= sisusbcon_init
,
1360 .con_deinit
= sisusbcon_deinit
,
1361 .con_clear
= sisusbcon_clear
,
1362 .con_putc
= sisusbcon_putc
,
1363 .con_putcs
= sisusbcon_putcs
,
1364 .con_cursor
= sisusbcon_cursor
,
1365 .con_scroll
= sisusbcon_scroll
,
1366 .con_bmove
= sisusbcon_bmove
,
1367 .con_switch
= sisusbcon_switch
,
1368 .con_blank
= sisusbcon_blank
,
1369 .con_font_set
= sisusbcon_font_set
,
1370 .con_font_get
= sisusbcon_font_get
,
1371 .con_set_palette
= sisusbcon_set_palette
,
1372 .con_scrolldelta
= sisusbcon_scrolldelta
,
1373 .con_build_attr
= sisusbcon_build_attr
,
1374 .con_invert_region
= sisusbcon_invert_region
,
1375 .con_set_origin
= sisusbcon_set_origin
,
1376 .con_save_screen
= sisusbcon_save_screen
,
1377 .con_resize
= sisusbcon_resize
,
1380 /* Our very own dummy console driver */
1382 static const char *sisusbdummycon_startup(void)
1384 return "SISUSBVGADUMMY";
1387 static void sisusbdummycon_init(struct vc_data
*vc
, int init
)
1389 vc
->vc_can_do_color
= 1;
1394 vc_resize(vc
, 80, 25);
1397 static int sisusbdummycon_dummy(void)
1402 #define SISUSBCONDUMMY (void *)sisusbdummycon_dummy
1404 static const struct consw sisusb_dummy_con
= {
1405 .owner
= THIS_MODULE
,
1406 .con_startup
= sisusbdummycon_startup
,
1407 .con_init
= sisusbdummycon_init
,
1408 .con_deinit
= SISUSBCONDUMMY
,
1409 .con_clear
= SISUSBCONDUMMY
,
1410 .con_putc
= SISUSBCONDUMMY
,
1411 .con_putcs
= SISUSBCONDUMMY
,
1412 .con_cursor
= SISUSBCONDUMMY
,
1413 .con_scroll
= SISUSBCONDUMMY
,
1414 .con_bmove
= SISUSBCONDUMMY
,
1415 .con_switch
= SISUSBCONDUMMY
,
1416 .con_blank
= SISUSBCONDUMMY
,
1417 .con_font_set
= SISUSBCONDUMMY
,
1418 .con_font_get
= SISUSBCONDUMMY
,
1419 .con_font_default
= SISUSBCONDUMMY
,
1420 .con_font_copy
= SISUSBCONDUMMY
,
1421 .con_set_palette
= SISUSBCONDUMMY
,
1422 .con_scrolldelta
= SISUSBCONDUMMY
,
1426 sisusb_console_init(struct sisusb_usb_data
*sisusb
, int first
, int last
)
1430 mutex_lock(&sisusb
->lock
);
1432 /* Erm.. that should not happen */
1433 if (sisusb
->haveconsole
|| !sisusb
->SiS_Pr
) {
1434 mutex_unlock(&sisusb
->lock
);
1438 sisusb
->con_first
= first
;
1439 sisusb
->con_last
= last
;
1442 first
> MAX_NR_CONSOLES
||
1443 last
> MAX_NR_CONSOLES
) {
1444 mutex_unlock(&sisusb
->lock
);
1448 /* If gfxcore not initialized or no consoles given, quit graciously */
1449 if (!sisusb
->gfxinit
|| first
< 1 || last
< 1) {
1450 mutex_unlock(&sisusb
->lock
);
1454 sisusb
->sisusb_cursor_loc
= -1;
1455 sisusb
->sisusb_cursor_size_from
= -1;
1456 sisusb
->sisusb_cursor_size_to
= -1;
1458 /* Set up text mode (and upload default font) */
1459 if (sisusb_reset_text_mode(sisusb
, 1)) {
1460 mutex_unlock(&sisusb
->lock
);
1461 dev_err(&sisusb
->sisusb_dev
->dev
, "Failed to set up text mode\n");
1465 /* Initialize some gfx registers */
1466 sisusb_initialize(sisusb
);
1468 for (i
= first
- 1; i
<= last
- 1; i
++) {
1469 /* Save sisusb for our interface routines */
1470 mysisusbs
[i
] = sisusb
;
1473 /* Initial console setup */
1474 sisusb
->sisusb_num_columns
= 80;
1476 /* Use a 32K buffer (matches b8000-bffff area) */
1477 sisusb
->scrbuf_size
= 32 * 1024;
1479 /* Allocate screen buffer */
1480 if (!(sisusb
->scrbuf
= (unsigned long)vmalloc(sisusb
->scrbuf_size
))) {
1481 mutex_unlock(&sisusb
->lock
);
1482 dev_err(&sisusb
->sisusb_dev
->dev
, "Failed to allocate screen buffer\n");
1486 mutex_unlock(&sisusb
->lock
);
1488 /* Now grab the desired console(s) */
1489 ret
= take_over_console(&sisusb_con
, first
- 1, last
- 1, 0);
1492 sisusb
->haveconsole
= 1;
1494 for (i
= first
- 1; i
<= last
- 1; i
++)
1495 mysisusbs
[i
] = NULL
;
1502 sisusb_console_exit(struct sisusb_usb_data
*sisusb
)
1506 /* This is called if the device is disconnected
1507 * and while disconnect and lock semaphores
1508 * are up. This should be save because we
1509 * can't lose our sisusb any other way but by
1510 * disconnection (and hence, the disconnect
1511 * sema is for protecting all other access
1512 * functions from disconnection, not the
1516 /* Now what do we do in case of disconnection:
1517 * One alternative would be to simply call
1518 * give_up_console(). Nah, not a good idea.
1519 * give_up_console() is obviously buggy as it
1520 * only discards the consw pointer from the
1521 * driver_map, but doesn't adapt vc->vc_sw
1522 * of the affected consoles. Hence, the next
1523 * call to any of the console functions will
1524 * eventually take a trip to oops county.
1525 * Also, give_up_console for some reason
1526 * doesn't decrement our module refcount.
1527 * Instead, we switch our consoles to a private
1528 * dummy console. This, of course, keeps our
1529 * refcount up as well, but it works perfectly.
1532 if (sisusb
->haveconsole
) {
1533 for (i
= 0; i
< MAX_NR_CONSOLES
; i
++)
1534 if (sisusb
->havethisconsole
[i
])
1535 take_over_console(&sisusb_dummy_con
, i
, i
, 0);
1536 /* At this point, con_deinit for all our
1537 * consoles is executed by take_over_console().
1539 sisusb
->haveconsole
= 0;
1542 vfree((void *)sisusb
->scrbuf
);
1545 vfree(sisusb
->font_backup
);
1546 sisusb
->font_backup
= NULL
;
1549 void __init
sisusb_init_concode(void)
1553 for (i
= 0; i
< MAX_NR_CONSOLES
; i
++)
1554 mysisusbs
[i
] = NULL
;
1557 #endif /* INCL_CON */