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;
123 /* Hardware bug: Text cursor appears twice or not at all
124 * at some positions. Work around it with the cursor skew
128 if ((location & 0x0007) == 0x0007) {
129 sisusb->bad_cursor_pos = 1;
131 if (sisusb_setidxregandor(sisusb, SISCR, 0x0b, 0x1f, 0x20))
133 } else if (sisusb->bad_cursor_pos) {
134 if (sisusb_setidxregand(sisusb, SISCR, 0x0b, 0x1f))
136 sisusb->bad_cursor_pos = 0;
139 if (sisusb_setidxreg(sisusb, SISCR, 0x0e, (location >> 8)))
141 sisusb_setidxreg(sisusb, SISCR, 0x0f, (location & 0xff));
144 static inline struct sisusb_usb_data *
145 sisusb_get_sisusb(unsigned short console)
147 return mysisusbs[console];
151 sisusb_sisusb_valid(struct sisusb_usb_data *sisusb)
153 if (!sisusb->present || !sisusb->ready || !sisusb->sisusb_dev)
159 static struct sisusb_usb_data *
160 sisusb_get_sisusb_lock_and_check(unsigned short console)
162 struct sisusb_usb_data *sisusb;
164 /* We can't handle console calls in non-schedulable
165 * context due to our locks and the USB transport.
166 * So we simply ignore them. This should only affect
167 * some calls to printk.
172 sisusb = sisusb_get_sisusb(console);
176 mutex_lock(&sisusb->lock);
178 if (!sisusb_sisusb_valid(sisusb) ||
179 !sisusb->havethisconsole[console]) {
180 mutex_unlock(&sisusb->lock);
188 sisusb_is_inactive(struct vc_data *c, struct sisusb_usb_data *sisusb)
190 if (sisusb->is_gfx ||
191 sisusb->textmodedestroyed ||
192 c->vc_mode != KD_TEXT)
198 /* con_startup console interface routine */
200 sisusbcon_startup(void)
205 /* con_init console interface routine */
207 sisusbcon_init(struct vc_data *c, int init)
209 struct sisusb_usb_data *sisusb;
212 /* This is called by do_take_over_console(),
213 * ie by us/under our control. It is
214 * only called after text mode and fonts
215 * are set up/restored.
218 sisusb = sisusb_get_sisusb(c->vc_num);
222 mutex_lock(&sisusb->lock);
224 if (!sisusb_sisusb_valid(sisusb)) {
225 mutex_unlock(&sisusb->lock);
229 c->vc_can_do_color = 1;
231 c->vc_complement_mask = 0x7700;
233 c->vc_hi_font_mask = sisusb->current_font_512 ? 0x0800 : 0;
235 sisusb->haveconsole = 1;
237 sisusb->havethisconsole[c->vc_num] = 1;
239 /* We only support 640x400 */
240 c->vc_scan_lines = 400;
242 c->vc_font.height = sisusb->current_font_height;
244 /* We only support width = 8 */
246 rows = c->vc_scan_lines / c->vc_font.height;
248 /* Increment usage count for our sisusb.
249 * Doing so saves us from upping/downing
250 * the disconnect semaphore; we can't
251 * lose our sisusb until this is undone
252 * in con_deinit. For all other console
253 * interface functions, it suffices to
254 * use sisusb->lock and do a quick check
255 * of sisusb for device disconnection.
257 kref_get(&sisusb->kref);
259 if (!*c->vc_uni_pagedir_loc)
260 con_set_default_unimap(c);
262 mutex_unlock(&sisusb->lock);
268 vc_resize(c, cols, rows);
271 /* con_deinit console interface routine */
273 sisusbcon_deinit(struct vc_data *c)
275 struct sisusb_usb_data *sisusb;
278 /* This is called by do_take_over_console()
279 * and others, ie not under our control.
282 sisusb = sisusb_get_sisusb(c->vc_num);
286 mutex_lock(&sisusb->lock);
288 /* Clear ourselves in mysisusbs */
289 mysisusbs[c->vc_num] = NULL;
291 sisusb->havethisconsole[c->vc_num] = 0;
293 /* Free our font buffer if all consoles are gone */
294 if (sisusb->font_backup) {
295 for(i = 0; i < MAX_NR_CONSOLES; i++) {
296 if (sisusb->havethisconsole[c->vc_num])
299 if (i == MAX_NR_CONSOLES) {
300 vfree(sisusb->font_backup);
301 sisusb->font_backup = NULL;
305 mutex_unlock(&sisusb->lock);
307 /* decrement the usage count on our sisusb */
308 kref_put(&sisusb->kref, sisusb_delete);
311 /* interface routine */
313 sisusbcon_build_attr(struct vc_data *c, u8 color, u8 intensity,
314 u8 blink, u8 underline, u8 reverse, u8 unused)
319 attr = (attr & 0xf0) | c->vc_ulcolor;
320 else if (intensity == 0)
321 attr = (attr & 0xf0) | c->vc_halfcolor;
324 attr = ((attr) & 0x88) |
326 ((attr) << 4)) & 0x77);
337 /* Interface routine */
339 sisusbcon_invert_region(struct vc_data *vc, u16 *p, int count)
341 /* Invert a region. This is called with a pointer
342 * to the console's internal screen buffer. So we
343 * simply do the inversion there and rely on
344 * a call to putc(s) to update the real screen.
348 u16 a = sisusbcon_readw(p);
351 (((a) & 0x7000) >> 4) |
352 (((a) & 0x0700) << 4);
354 sisusbcon_writew(a, p++);
358 #define SISUSB_VADDR(x,y) \
359 ((u16 *)c->vc_origin + \
360 (y) * sisusb->sisusb_num_columns + \
363 #define SISUSB_HADDR(x,y) \
364 ((u16 *)(sisusb->vrambase + (c->vc_origin - sisusb->scrbuf)) + \
365 (y) * sisusb->sisusb_num_columns + \
368 /* Interface routine */
370 sisusbcon_putc(struct vc_data *c, int ch, int y, int x)
372 struct sisusb_usb_data *sisusb;
374 sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num);
378 /* sisusb->lock is down */
379 if (sisusb_is_inactive(c, sisusb)) {
380 mutex_unlock(&sisusb->lock);
385 sisusb_copy_memory(sisusb, (char *)SISUSB_VADDR(x, y),
386 (long)SISUSB_HADDR(x, y), 2);
388 mutex_unlock(&sisusb->lock);
391 /* Interface routine */
393 sisusbcon_putcs(struct vc_data *c, const unsigned short *s,
394 int count, int y, int x)
396 struct sisusb_usb_data *sisusb;
400 sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num);
404 /* sisusb->lock is down */
406 /* Need to put the characters into the buffer ourselves,
407 * because the vt does this AFTER calling us.
410 dest = SISUSB_VADDR(x, y);
412 for (i = count; i > 0; i--)
413 sisusbcon_writew(sisusbcon_readw(s++), dest++);
415 if (sisusb_is_inactive(c, sisusb)) {
416 mutex_unlock(&sisusb->lock);
420 sisusb_copy_memory(sisusb, (char *)SISUSB_VADDR(x, y),
421 (long)SISUSB_HADDR(x, y), count * 2);
423 mutex_unlock(&sisusb->lock);
426 /* Interface routine */
428 sisusbcon_clear(struct vc_data *c, int y, int x, int height, int width)
430 struct sisusb_usb_data *sisusb;
431 u16 eattr = c->vc_video_erase_char;
435 if (width <= 0 || height <= 0)
438 sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num);
442 /* sisusb->lock is down */
444 /* Need to clear buffer ourselves, because the vt does
445 * this AFTER calling us.
448 dest = SISUSB_VADDR(x, y);
450 cols = sisusb->sisusb_num_columns;
455 if (x == 0 && width >= c->vc_cols) {
457 sisusbcon_memsetw(dest, eattr, height * cols * 2);
461 for (i = height; i > 0; i--, dest += cols)
462 sisusbcon_memsetw(dest, eattr, width * 2);
466 if (sisusb_is_inactive(c, sisusb)) {
467 mutex_unlock(&sisusb->lock);
471 length = ((height * cols) - x - (cols - width - x)) * 2;
474 sisusb_copy_memory(sisusb, (unsigned char *)SISUSB_VADDR(x, y),
475 (long)SISUSB_HADDR(x, y), length);
477 mutex_unlock(&sisusb->lock);
480 /* Interface routine */
482 sisusbcon_bmove(struct vc_data *c, int sy, int sx,
483 int dy, int dx, int height, int width)
485 struct sisusb_usb_data *sisusb;
488 if (width <= 0 || height <= 0)
491 sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num);
495 /* sisusb->lock is down */
497 cols = sisusb->sisusb_num_columns;
499 if (sisusb_is_inactive(c, sisusb)) {
500 mutex_unlock(&sisusb->lock);
504 length = ((height * cols) - dx - (cols - width - dx)) * 2;
507 sisusb_copy_memory(sisusb, (unsigned char *)SISUSB_VADDR(dx, dy),
508 (long)SISUSB_HADDR(dx, dy), length);
510 mutex_unlock(&sisusb->lock);
513 /* interface routine */
515 sisusbcon_switch(struct vc_data *c)
517 struct sisusb_usb_data *sisusb;
520 /* Returnvalue 0 means we have fully restored screen,
521 * and vt doesn't need to call do_update_region().
522 * Returnvalue != 0 naturally means the opposite.
525 sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num);
529 /* sisusb->lock is down */
531 /* Don't write to screen if in gfx mode */
532 if (sisusb_is_inactive(c, sisusb)) {
533 mutex_unlock(&sisusb->lock);
537 /* That really should not happen. It would mean we are
538 * being called while the vc is using its private buffer
541 if (c->vc_origin == (unsigned long)c->vc_screenbuf) {
542 mutex_unlock(&sisusb->lock);
543 dev_dbg(&sisusb->sisusb_dev->dev, "ASSERT ORIGIN != SCREENBUF!\n");
547 /* Check that we don't copy too much */
548 length = min((int)c->vc_screenbuf_size,
549 (int)(sisusb->scrbuf + sisusb->scrbuf_size - c->vc_origin));
551 /* Restore the screen contents */
552 sisusbcon_memcpyw((u16 *)c->vc_origin, (u16 *)c->vc_screenbuf,
555 sisusb_copy_memory(sisusb, (unsigned char *)c->vc_origin,
556 (long)SISUSB_HADDR(0, 0),
559 mutex_unlock(&sisusb->lock);
564 /* interface routine */
566 sisusbcon_save_screen(struct vc_data *c)
568 struct sisusb_usb_data *sisusb;
571 /* Save the current screen contents to vc's private
575 sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num);
579 /* sisusb->lock is down */
581 if (sisusb_is_inactive(c, sisusb)) {
582 mutex_unlock(&sisusb->lock);
586 /* Check that we don't copy too much */
587 length = min((int)c->vc_screenbuf_size,
588 (int)(sisusb->scrbuf + sisusb->scrbuf_size - c->vc_origin));
590 /* Save the screen contents to vc's private buffer */
591 sisusbcon_memcpyw((u16 *)c->vc_screenbuf, (u16 *)c->vc_origin,
594 mutex_unlock(&sisusb->lock);
597 /* interface routine */
599 sisusbcon_set_palette(struct vc_data *c, const unsigned char *table)
601 struct sisusb_usb_data *sisusb;
604 /* Return value not used by vt */
606 if (!CON_IS_VISIBLE(c))
609 sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num);
613 /* sisusb->lock is down */
615 if (sisusb_is_inactive(c, sisusb)) {
616 mutex_unlock(&sisusb->lock);
620 for (i = j = 0; i < 16; i++) {
621 if (sisusb_setreg(sisusb, SISCOLIDX, table[i]))
623 if (sisusb_setreg(sisusb, SISCOLDATA, c->vc_palette[j++] >> 2))
625 if (sisusb_setreg(sisusb, SISCOLDATA, c->vc_palette[j++] >> 2))
627 if (sisusb_setreg(sisusb, SISCOLDATA, c->vc_palette[j++] >> 2))
631 mutex_unlock(&sisusb->lock);
636 /* interface routine */
638 sisusbcon_blank(struct vc_data *c, int blank, int mode_switch)
640 struct sisusb_usb_data *sisusb;
641 u8 sr1, cr17, pmreg, cr63;
644 sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num);
648 /* sisusb->lock is down */
651 sisusb->is_gfx = blank ? 1 : 0;
653 if (sisusb_is_inactive(c, sisusb)) {
654 mutex_unlock(&sisusb->lock);
660 case 1: /* Normal blanking: Clear screen */
662 sisusbcon_memsetw((u16 *)c->vc_origin,
663 c->vc_video_erase_char,
664 c->vc_screenbuf_size);
665 sisusb_copy_memory(sisusb,
666 (unsigned char *)c->vc_origin,
667 (u32)(sisusb->vrambase +
668 (c->vc_origin - sisusb->scrbuf)),
669 c->vc_screenbuf_size);
670 sisusb->con_blanked = 1;
674 default: /* VESA blanking */
676 case 0: /* Unblank */
682 sisusb->con_blanked = 0;
684 case VESA_VSYNC_SUSPEND + 1:
690 case VESA_HSYNC_SUSPEND + 1:
696 case VESA_POWERDOWN + 1:
703 mutex_unlock(&sisusb->lock);
707 sisusb_setidxregandor(sisusb, SISSR, 0x01, ~0x20, sr1);
708 sisusb_setidxregandor(sisusb, SISCR, 0x17, 0x7f, cr17);
709 sisusb_setidxregandor(sisusb, SISSR, 0x1f, 0x3f, pmreg);
710 sisusb_setidxregandor(sisusb, SISCR, 0x63, 0xbf, cr63);
714 mutex_unlock(&sisusb->lock);
719 /* interface routine */
721 sisusbcon_scrolldelta(struct vc_data *c, int lines)
723 struct sisusb_usb_data *sisusb;
724 int margin = c->vc_size_row * 4;
727 /* The return value does not seem to be used */
729 sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num);
733 /* sisusb->lock is down */
735 if (sisusb_is_inactive(c, sisusb)) {
736 mutex_unlock(&sisusb->lock);
740 if (!lines) /* Turn scrollback off */
741 c->vc_visible_origin = c->vc_origin;
744 if (sisusb->con_rolled_over >
745 (c->vc_scr_end - sisusb->scrbuf) + margin) {
747 ul = c->vc_scr_end - sisusb->scrbuf;
748 we = sisusb->con_rolled_over + c->vc_size_row;
753 we = sisusb->scrbuf_size;
757 p = (c->vc_visible_origin - sisusb->scrbuf - ul + we) % we +
758 lines * c->vc_size_row;
760 st = (c->vc_origin - sisusb->scrbuf - ul + we) % we;
771 c->vc_visible_origin = sisusb->scrbuf + (p + ul) % we;
774 sisusbcon_set_start_address(sisusb, c);
776 mutex_unlock(&sisusb->lock);
781 /* Interface routine */
783 sisusbcon_cursor(struct vc_data *c, int mode)
785 struct sisusb_usb_data *sisusb;
786 int from, to, baseline;
788 sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num);
792 /* sisusb->lock is down */
794 if (sisusb_is_inactive(c, sisusb)) {
795 mutex_unlock(&sisusb->lock);
799 if (c->vc_origin != c->vc_visible_origin) {
800 c->vc_visible_origin = c->vc_origin;
801 sisusbcon_set_start_address(sisusb, c);
804 if (mode == CM_ERASE) {
805 sisusb_setidxregor(sisusb, SISCR, 0x0a, 0x20);
806 sisusb->sisusb_cursor_size_to = -1;
807 mutex_unlock(&sisusb->lock);
811 sisusb_set_cursor(sisusb, (c->vc_pos - sisusb->scrbuf) / 2);
813 baseline = c->vc_font.height - (c->vc_font.height < 10 ? 1 : 2);
815 switch (c->vc_cursor_type & 0x0f) {
816 case CUR_BLOCK: from = 1;
817 to = c->vc_font.height;
819 case CUR_TWO_THIRDS: from = c->vc_font.height / 3;
822 case CUR_LOWER_HALF: from = c->vc_font.height / 2;
825 case CUR_LOWER_THIRD: from = (c->vc_font.height * 2) / 3;
828 case CUR_NONE: from = 31;
832 case CUR_UNDERLINE: from = baseline - 1;
837 if (sisusb->sisusb_cursor_size_from != from ||
838 sisusb->sisusb_cursor_size_to != to) {
840 sisusb_setidxreg(sisusb, SISCR, 0x0a, from);
841 sisusb_setidxregandor(sisusb, SISCR, 0x0b, 0xe0, to);
843 sisusb->sisusb_cursor_size_from = from;
844 sisusb->sisusb_cursor_size_to = to;
847 mutex_unlock(&sisusb->lock);
851 sisusbcon_scroll_area(struct vc_data *c, struct sisusb_usb_data *sisusb,
852 int t, int b, int dir, int lines)
854 int cols = sisusb->sisusb_num_columns;
855 int length = ((b - t) * cols) * 2;
856 u16 eattr = c->vc_video_erase_char;
858 /* sisusb->lock is down */
860 /* Scroll an area which does not match the
861 * visible screen's dimensions. This needs
862 * to be done separately, as it does not
863 * use hardware panning.
869 sisusbcon_memmovew(SISUSB_VADDR(0, t),
870 SISUSB_VADDR(0, t + lines),
871 (b - t - lines) * cols * 2);
872 sisusbcon_memsetw(SISUSB_VADDR(0, b - lines), eattr,
877 sisusbcon_memmovew(SISUSB_VADDR(0, t + lines),
879 (b - t - lines) * cols * 2);
880 sisusbcon_memsetw(SISUSB_VADDR(0, t), eattr,
885 sisusb_copy_memory(sisusb, (char *)SISUSB_VADDR(0, t),
886 (long)SISUSB_HADDR(0, t), length);
888 mutex_unlock(&sisusb->lock);
893 /* Interface routine */
895 sisusbcon_scroll(struct vc_data *c, int t, int b, int dir, int lines)
897 struct sisusb_usb_data *sisusb;
898 u16 eattr = c->vc_video_erase_char;
900 unsigned long oldorigin;
901 unsigned int delta = lines * c->vc_size_row;
904 /* Returning != 0 means we have done the scrolling successfully.
905 * Returning 0 makes vt do the scrolling on its own.
906 * Note that con_scroll is only called if the console is
907 * visible. In that case, the origin should be our buffer,
908 * not the vt's private one.
914 sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num);
918 /* sisusb->lock is down */
920 if (sisusb_is_inactive(c, sisusb)) {
921 mutex_unlock(&sisusb->lock);
926 if (t || b != c->vc_rows)
927 return sisusbcon_scroll_area(c, sisusb, t, b, dir, lines);
929 if (c->vc_origin != c->vc_visible_origin) {
930 c->vc_visible_origin = c->vc_origin;
931 sisusbcon_set_start_address(sisusb, c);
934 /* limit amount to maximum realistic size */
935 if (lines > c->vc_rows)
938 oldorigin = c->vc_origin;
944 if (c->vc_scr_end + delta >=
945 sisusb->scrbuf + sisusb->scrbuf_size) {
946 sisusbcon_memcpyw((u16 *)sisusb->scrbuf,
947 (u16 *)(oldorigin + delta),
948 c->vc_screenbuf_size - delta);
949 c->vc_origin = sisusb->scrbuf;
950 sisusb->con_rolled_over = oldorigin - sisusb->scrbuf;
953 c->vc_origin += delta;
956 (u16 *)(c->vc_origin + c->vc_screenbuf_size - delta),
963 if (oldorigin - delta < sisusb->scrbuf) {
964 sisusbcon_memmovew((u16 *)(sisusb->scrbuf +
965 sisusb->scrbuf_size -
966 c->vc_screenbuf_size +
969 c->vc_screenbuf_size - delta);
970 c->vc_origin = sisusb->scrbuf +
971 sisusb->scrbuf_size -
972 c->vc_screenbuf_size;
973 sisusb->con_rolled_over = 0;
976 c->vc_origin -= delta;
978 c->vc_scr_end = c->vc_origin + c->vc_screenbuf_size;
980 scr_memsetw((u16 *)(c->vc_origin), eattr, delta);
985 originoffset = (u32)(c->vc_origin - sisusb->scrbuf);
988 sisusb_copy_memory(sisusb,
989 (char *)c->vc_origin,
990 (u32)(sisusb->vrambase + originoffset),
991 c->vc_screenbuf_size);
992 else if (dir == SM_UP)
993 sisusb_copy_memory(sisusb,
994 (char *)c->vc_origin + c->vc_screenbuf_size - delta,
995 (u32)sisusb->vrambase + originoffset +
996 c->vc_screenbuf_size - delta,
999 sisusb_copy_memory(sisusb,
1000 (char *)c->vc_origin,
1001 (u32)(sisusb->vrambase + originoffset),
1004 c->vc_scr_end = c->vc_origin + c->vc_screenbuf_size;
1005 c->vc_visible_origin = c->vc_origin;
1007 sisusbcon_set_start_address(sisusb, c);
1009 c->vc_pos = c->vc_pos - oldorigin + c->vc_origin;
1011 mutex_unlock(&sisusb->lock);
1016 /* Interface routine */
1018 sisusbcon_set_origin(struct vc_data *c)
1020 struct sisusb_usb_data *sisusb;
1022 /* Returning != 0 means we were successful.
1023 * Returning 0 will vt make to use its own
1024 * screenbuffer as the origin.
1027 sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num);
1031 /* sisusb->lock is down */
1033 if (sisusb_is_inactive(c, sisusb) || sisusb->con_blanked) {
1034 mutex_unlock(&sisusb->lock);
1038 c->vc_origin = c->vc_visible_origin = sisusb->scrbuf;
1040 sisusbcon_set_start_address(sisusb, c);
1042 sisusb->con_rolled_over = 0;
1044 mutex_unlock(&sisusb->lock);
1049 /* Interface routine */
1051 sisusbcon_resize(struct vc_data *c, unsigned int newcols, unsigned int newrows,
1054 struct sisusb_usb_data *sisusb;
1057 sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num);
1061 fh = sisusb->current_font_height;
1063 mutex_unlock(&sisusb->lock);
1065 /* We are quite unflexible as regards resizing. The vt code
1066 * handles sizes where the line length isn't equal the pitch
1067 * quite badly. As regards the rows, our panning tricks only
1068 * work well if the number of rows equals the visible number
1072 if (newcols != 80 || c->vc_scan_lines / fh != newrows)
1079 sisusbcon_do_font_op(struct sisusb_usb_data *sisusb, int set, int slot,
1080 u8 *arg, int cmapsz, int ch512, int dorecalc,
1081 struct vc_data *c, int fh, int uplock)
1083 int font_select = 0x00, i, err = 0;
1087 /* sisusb->lock is down */
1090 * The default font is kept in slot 0.
1091 * A user font is loaded in slot 2 (256 ch)
1095 if ((slot != 0 && slot != 2) || !fh) {
1097 mutex_unlock(&sisusb->lock);
1102 sisusb->font_slot = slot;
1104 /* Default font is always 256 */
1108 offset = 4 * cmapsz;
1110 font_select = (slot == 0) ? 0x00 : (ch512 ? 0x0e : 0x0a);
1112 err |= sisusb_setidxreg(sisusb, SISSR, 0x00, 0x01); /* Reset */
1113 err |= sisusb_setidxreg(sisusb, SISSR, 0x02, 0x04); /* Write to plane 2 */
1114 err |= sisusb_setidxreg(sisusb, SISSR, 0x04, 0x07); /* Memory mode a0-bf */
1115 err |= sisusb_setidxreg(sisusb, SISSR, 0x00, 0x03); /* Reset */
1120 err |= sisusb_setidxreg(sisusb, SISGR, 0x04, 0x03); /* Select plane read 2 */
1121 err |= sisusb_setidxreg(sisusb, SISGR, 0x05, 0x00); /* Disable odd/even */
1122 err |= sisusb_setidxreg(sisusb, SISGR, 0x06, 0x00); /* Address range a0-bf */
1129 for (i = 0; i < cmapsz; i++) {
1130 err |= sisusb_writeb(sisusb,
1131 sisusb->vrambase + offset + i,
1137 for (i = 0; i < cmapsz; i++) {
1138 err |= sisusb_readb(sisusb,
1139 sisusb->vrambase + offset + i,
1146 * In 512-character mode, the character map is not contiguous if
1147 * we want to remain EGA compatible -- which we do
1152 for (i = 0; i < cmapsz; i++) {
1153 err |= sisusb_writeb(sisusb,
1154 sisusb->vrambase + offset +
1161 for (i = 0; i < cmapsz; i++) {
1162 err |= sisusb_readb(sisusb,
1163 sisusb->vrambase + offset +
1175 err |= sisusb_setidxreg(sisusb, SISSR, 0x00, 0x01); /* Reset */
1176 err |= sisusb_setidxreg(sisusb, SISSR, 0x02, 0x03); /* Write to planes 0+1 */
1177 err |= sisusb_setidxreg(sisusb, SISSR, 0x04, 0x03); /* Memory mode a0-bf */
1179 sisusb_setidxreg(sisusb, SISSR, 0x03, font_select);
1180 err |= sisusb_setidxreg(sisusb, SISSR, 0x00, 0x03); /* Reset end */
1185 err |= sisusb_setidxreg(sisusb, SISGR, 0x04, 0x00); /* Select plane read 0 */
1186 err |= sisusb_setidxreg(sisusb, SISGR, 0x05, 0x10); /* Enable odd/even */
1187 err |= sisusb_setidxreg(sisusb, SISGR, 0x06, 0x06); /* Address range b8-bf */
1192 if ((set) && (ch512 != sisusb->current_font_512)) {
1194 /* Font is shared among all our consoles.
1195 * And so is the hi_font_mask.
1197 for (i = 0; i < MAX_NR_CONSOLES; i++) {
1198 struct vc_data *d = vc_cons[i].d;
1199 if (d && d->vc_sw == &sisusb_con)
1200 d->vc_hi_font_mask = ch512 ? 0x0800 : 0;
1203 sisusb->current_font_512 = ch512;
1205 /* color plane enable register:
1206 256-char: enable intensity bit
1207 512-char: disable intensity bit */
1208 sisusb_getreg(sisusb, SISINPSTAT, &dummy);
1209 sisusb_setreg(sisusb, SISAR, 0x12);
1210 sisusb_setreg(sisusb, SISAR, ch512 ? 0x07 : 0x0f);
1212 sisusb_getreg(sisusb, SISINPSTAT, &dummy);
1213 sisusb_setreg(sisusb, SISAR, 0x20);
1214 sisusb_getreg(sisusb, SISINPSTAT, &dummy);
1220 * Adjust the screen to fit a font of a certain height
1223 unsigned char ovr, vde, fsr;
1224 int rows = 0, maxscan = 0;
1228 /* Number of video rows */
1229 rows = c->vc_scan_lines / fh;
1230 /* Scan lines to actually display-1 */
1231 maxscan = rows * fh - 1;
1233 /*printk(KERN_DEBUG "sisusb recalc rows %d maxscan %d fh %d sl %d\n",
1234 rows, maxscan, fh, c->vc_scan_lines);*/
1236 sisusb_getidxreg(sisusb, SISCR, 0x07, &ovr);
1237 vde = maxscan & 0xff;
1238 ovr = (ovr & 0xbd) |
1239 ((maxscan & 0x100) >> 7) |
1240 ((maxscan & 0x200) >> 3);
1241 sisusb_setidxreg(sisusb, SISCR, 0x07, ovr);
1242 sisusb_setidxreg(sisusb, SISCR, 0x12, vde);
1246 sisusb_getidxreg(sisusb, SISCR, 0x09, &fsr);
1247 fsr = (fsr & 0xe0) | (fh - 1);
1248 sisusb_setidxreg(sisusb, SISCR, 0x09, fsr);
1249 sisusb->current_font_height = fh;
1251 sisusb->sisusb_cursor_size_from = -1;
1252 sisusb->sisusb_cursor_size_to = -1;
1257 mutex_unlock(&sisusb->lock);
1259 if (dorecalc && c) {
1260 int rows = c->vc_scan_lines / fh;
1262 /* Now adjust our consoles' size */
1264 for (i = 0; i < MAX_NR_CONSOLES; i++) {
1265 struct vc_data *vc = vc_cons[i].d;
1267 if (vc && vc->vc_sw == &sisusb_con) {
1268 if (CON_IS_VISIBLE(vc)) {
1269 vc->vc_sw->con_cursor(vc, CM_DRAW);
1271 vc->vc_font.height = fh;
1272 vc_resize(vc, 0, rows);
1281 mutex_unlock(&sisusb->lock);
1286 /* Interface routine */
1288 sisusbcon_font_set(struct vc_data *c, struct console_font *font,
1291 struct sisusb_usb_data *sisusb;
1292 unsigned charcount = font->charcount;
1294 if (font->width != 8 || (charcount != 256 && charcount != 512))
1297 sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num);
1301 /* sisusb->lock is down */
1303 /* Save the user-provided font into a buffer. This
1304 * is used for restoring text mode after quitting
1305 * from X and for the con_getfont routine.
1307 if (sisusb->font_backup) {
1308 if (sisusb->font_backup_size < charcount) {
1309 vfree(sisusb->font_backup);
1310 sisusb->font_backup = NULL;
1314 if (!sisusb->font_backup)
1315 sisusb->font_backup = vmalloc(charcount * 32);
1317 if (sisusb->font_backup) {
1318 memcpy(sisusb->font_backup, font->data, charcount * 32);
1319 sisusb->font_backup_size = charcount;
1320 sisusb->font_backup_height = font->height;
1321 sisusb->font_backup_512 = (charcount == 512) ? 1 : 0;
1324 /* do_font_op ups sisusb->lock */
1326 return sisusbcon_do_font_op(sisusb, 1, 2, font->data,
1327 8192, (charcount == 512),
1328 (!(flags & KD_FONT_FLAG_DONT_RECALC)) ? 1 : 0,
1329 c, font->height, 1);
1332 /* Interface routine */
1334 sisusbcon_font_get(struct vc_data *c, struct console_font *font)
1336 struct sisusb_usb_data *sisusb;
1338 sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num);
1342 /* sisusb->lock is down */
1345 font->height = c->vc_font.height;
1346 font->charcount = 256;
1349 mutex_unlock(&sisusb->lock);
1353 if (!sisusb->font_backup) {
1354 mutex_unlock(&sisusb->lock);
1358 /* Copy 256 chars only, like vgacon */
1359 memcpy(font->data, sisusb->font_backup, 256 * 32);
1361 mutex_unlock(&sisusb->lock);
1367 * The console `switch' structure for the sisusb console
1370 static const struct consw sisusb_con = {
1371 .owner = THIS_MODULE,
1372 .con_startup = sisusbcon_startup,
1373 .con_init = sisusbcon_init,
1374 .con_deinit = sisusbcon_deinit,
1375 .con_clear = sisusbcon_clear,
1376 .con_putc = sisusbcon_putc,
1377 .con_putcs = sisusbcon_putcs,
1378 .con_cursor = sisusbcon_cursor,
1379 .con_scroll = sisusbcon_scroll,
1380 .con_bmove = sisusbcon_bmove,
1381 .con_switch = sisusbcon_switch,
1382 .con_blank = sisusbcon_blank,
1383 .con_font_set = sisusbcon_font_set,
1384 .con_font_get = sisusbcon_font_get,
1385 .con_set_palette = sisusbcon_set_palette,
1386 .con_scrolldelta = sisusbcon_scrolldelta,
1387 .con_build_attr = sisusbcon_build_attr,
1388 .con_invert_region = sisusbcon_invert_region,
1389 .con_set_origin = sisusbcon_set_origin,
1390 .con_save_screen = sisusbcon_save_screen,
1391 .con_resize = sisusbcon_resize,
1394 /* Our very own dummy console driver */
1396 static const char *sisusbdummycon_startup(void)
1398 return "SISUSBVGADUMMY";
1401 static void sisusbdummycon_init(struct vc_data *vc, int init)
1403 vc->vc_can_do_color = 1;
1408 vc_resize(vc, 80, 25);
1411 static int sisusbdummycon_dummy(void)
1416 #define SISUSBCONDUMMY (void *)sisusbdummycon_dummy
1418 static const struct consw sisusb_dummy_con = {
1419 .owner = THIS_MODULE,
1420 .con_startup = sisusbdummycon_startup,
1421 .con_init = sisusbdummycon_init,
1422 .con_deinit = SISUSBCONDUMMY,
1423 .con_clear = SISUSBCONDUMMY,
1424 .con_putc = SISUSBCONDUMMY,
1425 .con_putcs = SISUSBCONDUMMY,
1426 .con_cursor = SISUSBCONDUMMY,
1427 .con_scroll = SISUSBCONDUMMY,
1428 .con_bmove = SISUSBCONDUMMY,
1429 .con_switch = SISUSBCONDUMMY,
1430 .con_blank = SISUSBCONDUMMY,
1431 .con_font_set = SISUSBCONDUMMY,
1432 .con_font_get = SISUSBCONDUMMY,
1433 .con_font_default = SISUSBCONDUMMY,
1434 .con_font_copy = SISUSBCONDUMMY,
1435 .con_set_palette = SISUSBCONDUMMY,
1436 .con_scrolldelta = SISUSBCONDUMMY,
1440 sisusb_console_init(struct sisusb_usb_data *sisusb, int first, int last)
1444 mutex_lock(&sisusb->lock);
1446 /* Erm.. that should not happen */
1447 if (sisusb->haveconsole || !sisusb->SiS_Pr) {
1448 mutex_unlock(&sisusb->lock);
1452 sisusb->con_first = first;
1453 sisusb->con_last = last;
1456 first > MAX_NR_CONSOLES ||
1457 last > MAX_NR_CONSOLES) {
1458 mutex_unlock(&sisusb->lock);
1462 /* If gfxcore not initialized or no consoles given, quit graciously */
1463 if (!sisusb->gfxinit || first < 1 || last < 1) {
1464 mutex_unlock(&sisusb->lock);
1468 sisusb->sisusb_cursor_loc = -1;
1469 sisusb->sisusb_cursor_size_from = -1;
1470 sisusb->sisusb_cursor_size_to = -1;
1472 /* Set up text mode (and upload default font) */
1473 if (sisusb_reset_text_mode(sisusb, 1)) {
1474 mutex_unlock(&sisusb->lock);
1475 dev_err(&sisusb->sisusb_dev->dev, "Failed to set up text mode\n");
1479 /* Initialize some gfx registers */
1480 sisusb_initialize(sisusb);
1482 for (i = first - 1; i <= last - 1; i++) {
1483 /* Save sisusb for our interface routines */
1484 mysisusbs[i] = sisusb;
1487 /* Initial console setup */
1488 sisusb->sisusb_num_columns = 80;
1490 /* Use a 32K buffer (matches b8000-bffff area) */
1491 sisusb->scrbuf_size = 32 * 1024;
1493 /* Allocate screen buffer */
1494 if (!(sisusb->scrbuf = (unsigned long)vmalloc(sisusb->scrbuf_size))) {
1495 mutex_unlock(&sisusb->lock);
1496 dev_err(&sisusb->sisusb_dev->dev, "Failed to allocate screen buffer\n");
1500 mutex_unlock(&sisusb->lock);
1502 /* Now grab the desired console(s) */
1504 ret = do_take_over_console(&sisusb_con, first - 1, last - 1, 0);
1507 sisusb->haveconsole = 1;
1509 for (i = first - 1; i <= last - 1; i++)
1510 mysisusbs[i] = NULL;
1517 sisusb_console_exit(struct sisusb_usb_data *sisusb)
1521 /* This is called if the device is disconnected
1522 * and while disconnect and lock semaphores
1523 * are up. This should be save because we
1524 * can't lose our sisusb any other way but by
1525 * disconnection (and hence, the disconnect
1526 * sema is for protecting all other access
1527 * functions from disconnection, not the
1531 /* Now what do we do in case of disconnection:
1532 * One alternative would be to simply call
1533 * give_up_console(). Nah, not a good idea.
1534 * give_up_console() is obviously buggy as it
1535 * only discards the consw pointer from the
1536 * driver_map, but doesn't adapt vc->vc_sw
1537 * of the affected consoles. Hence, the next
1538 * call to any of the console functions will
1539 * eventually take a trip to oops county.
1540 * Also, give_up_console for some reason
1541 * doesn't decrement our module refcount.
1542 * Instead, we switch our consoles to a private
1543 * dummy console. This, of course, keeps our
1544 * refcount up as well, but it works perfectly.
1547 if (sisusb->haveconsole) {
1548 for (i = 0; i < MAX_NR_CONSOLES; i++)
1549 if (sisusb->havethisconsole[i]) {
1551 do_take_over_console(&sisusb_dummy_con, i, i, 0);
1553 /* At this point, con_deinit for all our
1554 * consoles is executed by do_take_over_console().
1557 sisusb->haveconsole = 0;
1560 vfree((void *)sisusb->scrbuf);
1563 vfree(sisusb->font_backup);
1564 sisusb->font_backup = NULL;
1567 void __init sisusb_init_concode(void)
1571 for (i = 0; i < MAX_NR_CONSOLES; i++)
1572 mysisusbs[i] = NULL;
1575 #endif /* INCL_CON */