Loading...
1/*
2 * sisusb - usb kernel driver for SiS315(E) based USB2VGA dongles
3 *
4 * VGA text mode console part
5 *
6 * Copyright (C) 2005 by Thomas Winischhofer, Vienna, Austria
7 *
8 * If distributed as part of the Linux kernel, this code is licensed under the
9 * terms of the GPL v2.
10 *
11 * Otherwise, the following license terms apply:
12 *
13 * * Redistribution and use in source and binary forms, with or without
14 * * modification, are permitted provided that the following conditions
15 * * are met:
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.
23 * *
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.
34 *
35 * Author: Thomas Winischhofer <thomas@winischhofer.net>
36 *
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
41 * 1995 Jay Estabrook
42 *
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
46 * detects this state.
47 *
48 */
49
50#include <linux/mutex.h>
51#include <linux/module.h>
52#include <linux/kernel.h>
53#include <linux/signal.h>
54#include <linux/fs.h>
55#include <linux/usb.h>
56#include <linux/tty.h>
57#include <linux/console.h>
58#include <linux/string.h>
59#include <linux/kd.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>
68
69#include "sisusb.h"
70#include "sisusb_init.h"
71
72#ifdef INCL_SISUSB_CON
73
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)
78
79/* vc_data -> sisusb conversion table */
80static struct sisusb_usb_data *mysisusbs[MAX_NR_CONSOLES];
81
82/* Forward declaration */
83static const struct consw sisusb_con;
84
85static inline void
86sisusbcon_memsetw(u16 *s, u16 c, unsigned int count)
87{
88 count /= 2;
89 while (count--)
90 sisusbcon_writew(c, s++);
91}
92
93static inline void
94sisusb_initialize(struct sisusb_usb_data *sisusb)
95{
96 /* Reset cursor and start address */
97 if (sisusb_setidxreg(sisusb, SISCR, 0x0c, 0x00))
98 return;
99 if (sisusb_setidxreg(sisusb, SISCR, 0x0d, 0x00))
100 return;
101 if (sisusb_setidxreg(sisusb, SISCR, 0x0e, 0x00))
102 return;
103 sisusb_setidxreg(sisusb, SISCR, 0x0f, 0x00);
104}
105
106static inline void
107sisusbcon_set_start_address(struct sisusb_usb_data *sisusb, struct vc_data *c)
108{
109 sisusb->cur_start_addr = (c->vc_visible_origin - sisusb->scrbuf) / 2;
110
111 sisusb_setidxreg(sisusb, SISCR, 0x0c, (sisusb->cur_start_addr >> 8));
112 sisusb_setidxreg(sisusb, SISCR, 0x0d, (sisusb->cur_start_addr & 0xff));
113}
114
115void
116sisusb_set_cursor(struct sisusb_usb_data *sisusb, unsigned int location)
117{
118 if (sisusb->sisusb_cursor_loc == location)
119 return;
120
121 sisusb->sisusb_cursor_loc = location;
122
123 /* Hardware bug: Text cursor appears twice or not at all
124 * at some positions. Work around it with the cursor skew
125 * bits.
126 */
127
128 if ((location & 0x0007) == 0x0007) {
129 sisusb->bad_cursor_pos = 1;
130 location--;
131 if (sisusb_setidxregandor(sisusb, SISCR, 0x0b, 0x1f, 0x20))
132 return;
133 } else if (sisusb->bad_cursor_pos) {
134 if (sisusb_setidxregand(sisusb, SISCR, 0x0b, 0x1f))
135 return;
136 sisusb->bad_cursor_pos = 0;
137 }
138
139 if (sisusb_setidxreg(sisusb, SISCR, 0x0e, (location >> 8)))
140 return;
141 sisusb_setidxreg(sisusb, SISCR, 0x0f, (location & 0xff));
142}
143
144static inline struct sisusb_usb_data *
145sisusb_get_sisusb(unsigned short console)
146{
147 return mysisusbs[console];
148}
149
150static inline int
151sisusb_sisusb_valid(struct sisusb_usb_data *sisusb)
152{
153 if (!sisusb->present || !sisusb->ready || !sisusb->sisusb_dev)
154 return 0;
155
156 return 1;
157}
158
159static struct sisusb_usb_data *
160sisusb_get_sisusb_lock_and_check(unsigned short console)
161{
162 struct sisusb_usb_data *sisusb;
163
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.
168 */
169 if (in_atomic())
170 return NULL;
171
172 sisusb = sisusb_get_sisusb(console);
173 if (!sisusb)
174 return NULL;
175
176 mutex_lock(&sisusb->lock);
177
178 if (!sisusb_sisusb_valid(sisusb) ||
179 !sisusb->havethisconsole[console]) {
180 mutex_unlock(&sisusb->lock);
181 return NULL;
182 }
183
184 return sisusb;
185}
186
187static int
188sisusb_is_inactive(struct vc_data *c, struct sisusb_usb_data *sisusb)
189{
190 if (sisusb->is_gfx ||
191 sisusb->textmodedestroyed ||
192 c->vc_mode != KD_TEXT)
193 return 1;
194
195 return 0;
196}
197
198/* con_startup console interface routine */
199static const char *
200sisusbcon_startup(void)
201{
202 return "SISUSBCON";
203}
204
205/* con_init console interface routine */
206static void
207sisusbcon_init(struct vc_data *c, int init)
208{
209 struct sisusb_usb_data *sisusb;
210 int cols, rows;
211
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.
216 */
217
218 sisusb = sisusb_get_sisusb(c->vc_num);
219 if (!sisusb)
220 return;
221
222 mutex_lock(&sisusb->lock);
223
224 if (!sisusb_sisusb_valid(sisusb)) {
225 mutex_unlock(&sisusb->lock);
226 return;
227 }
228
229 c->vc_can_do_color = 1;
230
231 c->vc_complement_mask = 0x7700;
232
233 c->vc_hi_font_mask = sisusb->current_font_512 ? 0x0800 : 0;
234
235 sisusb->haveconsole = 1;
236
237 sisusb->havethisconsole[c->vc_num] = 1;
238
239 /* We only support 640x400 */
240 c->vc_scan_lines = 400;
241
242 c->vc_font.height = sisusb->current_font_height;
243
244 /* We only support width = 8 */
245 cols = 80;
246 rows = c->vc_scan_lines / c->vc_font.height;
247
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.
256 */
257 kref_get(&sisusb->kref);
258
259 if (!*c->vc_uni_pagedir_loc)
260 con_set_default_unimap(c);
261
262 mutex_unlock(&sisusb->lock);
263
264 if (init) {
265 c->vc_cols = cols;
266 c->vc_rows = rows;
267 } else
268 vc_resize(c, cols, rows);
269}
270
271/* con_deinit console interface routine */
272static void
273sisusbcon_deinit(struct vc_data *c)
274{
275 struct sisusb_usb_data *sisusb;
276 int i;
277
278 /* This is called by do_take_over_console()
279 * and others, ie not under our control.
280 */
281
282 sisusb = sisusb_get_sisusb(c->vc_num);
283 if (!sisusb)
284 return;
285
286 mutex_lock(&sisusb->lock);
287
288 /* Clear ourselves in mysisusbs */
289 mysisusbs[c->vc_num] = NULL;
290
291 sisusb->havethisconsole[c->vc_num] = 0;
292
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])
297 break;
298 }
299 if (i == MAX_NR_CONSOLES) {
300 vfree(sisusb->font_backup);
301 sisusb->font_backup = NULL;
302 }
303 }
304
305 mutex_unlock(&sisusb->lock);
306
307 /* decrement the usage count on our sisusb */
308 kref_put(&sisusb->kref, sisusb_delete);
309}
310
311/* interface routine */
312static u8
313sisusbcon_build_attr(struct vc_data *c, u8 color, u8 intensity,
314 u8 blink, u8 underline, u8 reverse, u8 unused)
315{
316 u8 attr = color;
317
318 if (underline)
319 attr = (attr & 0xf0) | c->vc_ulcolor;
320 else if (intensity == 0)
321 attr = (attr & 0xf0) | c->vc_halfcolor;
322
323 if (reverse)
324 attr = ((attr) & 0x88) |
325 ((((attr) >> 4) |
326 ((attr) << 4)) & 0x77);
327
328 if (blink)
329 attr ^= 0x80;
330
331 if (intensity == 2)
332 attr ^= 0x08;
333
334 return attr;
335}
336
337/* Interface routine */
338static void
339sisusbcon_invert_region(struct vc_data *vc, u16 *p, int count)
340{
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.
345 */
346
347 while (count--) {
348 u16 a = sisusbcon_readw(p);
349
350 a = ((a) & 0x88ff) |
351 (((a) & 0x7000) >> 4) |
352 (((a) & 0x0700) << 4);
353
354 sisusbcon_writew(a, p++);
355 }
356}
357
358#define SISUSB_VADDR(x,y) \
359 ((u16 *)c->vc_origin + \
360 (y) * sisusb->sisusb_num_columns + \
361 (x))
362
363#define SISUSB_HADDR(x,y) \
364 ((u16 *)(sisusb->vrambase + (c->vc_origin - sisusb->scrbuf)) + \
365 (y) * sisusb->sisusb_num_columns + \
366 (x))
367
368/* Interface routine */
369static void
370sisusbcon_putc(struct vc_data *c, int ch, int y, int x)
371{
372 struct sisusb_usb_data *sisusb;
373 ssize_t written;
374
375 sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num);
376 if (!sisusb)
377 return;
378
379 /* sisusb->lock is down */
380 if (sisusb_is_inactive(c, sisusb)) {
381 mutex_unlock(&sisusb->lock);
382 return;
383 }
384
385
386 sisusb_copy_memory(sisusb, (char *)SISUSB_VADDR(x, y),
387 (long)SISUSB_HADDR(x, y), 2, &written);
388
389 mutex_unlock(&sisusb->lock);
390}
391
392/* Interface routine */
393static void
394sisusbcon_putcs(struct vc_data *c, const unsigned short *s,
395 int count, int y, int x)
396{
397 struct sisusb_usb_data *sisusb;
398 ssize_t written;
399 u16 *dest;
400 int i;
401
402 sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num);
403 if (!sisusb)
404 return;
405
406 /* sisusb->lock is down */
407
408 /* Need to put the characters into the buffer ourselves,
409 * because the vt does this AFTER calling us.
410 */
411
412 dest = SISUSB_VADDR(x, y);
413
414 for (i = count; i > 0; i--)
415 sisusbcon_writew(sisusbcon_readw(s++), dest++);
416
417 if (sisusb_is_inactive(c, sisusb)) {
418 mutex_unlock(&sisusb->lock);
419 return;
420 }
421
422 sisusb_copy_memory(sisusb, (char *)SISUSB_VADDR(x, y),
423 (long)SISUSB_HADDR(x, y), count * 2, &written);
424
425 mutex_unlock(&sisusb->lock);
426}
427
428/* Interface routine */
429static void
430sisusbcon_clear(struct vc_data *c, int y, int x, int height, int width)
431{
432 struct sisusb_usb_data *sisusb;
433 u16 eattr = c->vc_video_erase_char;
434 ssize_t written;
435 int i, length, cols;
436 u16 *dest;
437
438 if (width <= 0 || height <= 0)
439 return;
440
441 sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num);
442 if (!sisusb)
443 return;
444
445 /* sisusb->lock is down */
446
447 /* Need to clear buffer ourselves, because the vt does
448 * this AFTER calling us.
449 */
450
451 dest = SISUSB_VADDR(x, y);
452
453 cols = sisusb->sisusb_num_columns;
454
455 if (width > cols)
456 width = cols;
457
458 if (x == 0 && width >= c->vc_cols) {
459
460 sisusbcon_memsetw(dest, eattr, height * cols * 2);
461
462 } else {
463
464 for (i = height; i > 0; i--, dest += cols)
465 sisusbcon_memsetw(dest, eattr, width * 2);
466
467 }
468
469 if (sisusb_is_inactive(c, sisusb)) {
470 mutex_unlock(&sisusb->lock);
471 return;
472 }
473
474 length = ((height * cols) - x - (cols - width - x)) * 2;
475
476
477 sisusb_copy_memory(sisusb, (unsigned char *)SISUSB_VADDR(x, y),
478 (long)SISUSB_HADDR(x, y), length, &written);
479
480 mutex_unlock(&sisusb->lock);
481}
482
483/* Interface routine */
484static void
485sisusbcon_bmove(struct vc_data *c, int sy, int sx,
486 int dy, int dx, int height, int width)
487{
488 struct sisusb_usb_data *sisusb;
489 ssize_t written;
490 int cols, length;
491
492 if (width <= 0 || height <= 0)
493 return;
494
495 sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num);
496 if (!sisusb)
497 return;
498
499 /* sisusb->lock is down */
500
501 cols = sisusb->sisusb_num_columns;
502
503 if (sisusb_is_inactive(c, sisusb)) {
504 mutex_unlock(&sisusb->lock);
505 return;
506 }
507
508 length = ((height * cols) - dx - (cols - width - dx)) * 2;
509
510
511 sisusb_copy_memory(sisusb, (unsigned char *)SISUSB_VADDR(dx, dy),
512 (long)SISUSB_HADDR(dx, dy), length, &written);
513
514 mutex_unlock(&sisusb->lock);
515}
516
517/* interface routine */
518static int
519sisusbcon_switch(struct vc_data *c)
520{
521 struct sisusb_usb_data *sisusb;
522 ssize_t written;
523 int length;
524
525 /* Returnvalue 0 means we have fully restored screen,
526 * and vt doesn't need to call do_update_region().
527 * Returnvalue != 0 naturally means the opposite.
528 */
529
530 sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num);
531 if (!sisusb)
532 return 0;
533
534 /* sisusb->lock is down */
535
536 /* Don't write to screen if in gfx mode */
537 if (sisusb_is_inactive(c, sisusb)) {
538 mutex_unlock(&sisusb->lock);
539 return 0;
540 }
541
542 /* That really should not happen. It would mean we are
543 * being called while the vc is using its private buffer
544 * as origin.
545 */
546 if (c->vc_origin == (unsigned long)c->vc_screenbuf) {
547 mutex_unlock(&sisusb->lock);
548 dev_dbg(&sisusb->sisusb_dev->dev, "ASSERT ORIGIN != SCREENBUF!\n");
549 return 0;
550 }
551
552 /* Check that we don't copy too much */
553 length = min((int)c->vc_screenbuf_size,
554 (int)(sisusb->scrbuf + sisusb->scrbuf_size - c->vc_origin));
555
556 /* Restore the screen contents */
557 sisusbcon_memcpyw((u16 *)c->vc_origin, (u16 *)c->vc_screenbuf,
558 length);
559
560 sisusb_copy_memory(sisusb, (unsigned char *)c->vc_origin,
561 (long)SISUSB_HADDR(0, 0),
562 length, &written);
563
564 mutex_unlock(&sisusb->lock);
565
566 return 0;
567}
568
569/* interface routine */
570static void
571sisusbcon_save_screen(struct vc_data *c)
572{
573 struct sisusb_usb_data *sisusb;
574 int length;
575
576 /* Save the current screen contents to vc's private
577 * buffer.
578 */
579
580 sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num);
581 if (!sisusb)
582 return;
583
584 /* sisusb->lock is down */
585
586 if (sisusb_is_inactive(c, sisusb)) {
587 mutex_unlock(&sisusb->lock);
588 return;
589 }
590
591 /* Check that we don't copy too much */
592 length = min((int)c->vc_screenbuf_size,
593 (int)(sisusb->scrbuf + sisusb->scrbuf_size - c->vc_origin));
594
595 /* Save the screen contents to vc's private buffer */
596 sisusbcon_memcpyw((u16 *)c->vc_screenbuf, (u16 *)c->vc_origin,
597 length);
598
599 mutex_unlock(&sisusb->lock);
600}
601
602/* interface routine */
603static int
604sisusbcon_set_palette(struct vc_data *c, unsigned char *table)
605{
606 struct sisusb_usb_data *sisusb;
607 int i, j;
608
609 /* Return value not used by vt */
610
611 if (!CON_IS_VISIBLE(c))
612 return -EINVAL;
613
614 sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num);
615 if (!sisusb)
616 return -EINVAL;
617
618 /* sisusb->lock is down */
619
620 if (sisusb_is_inactive(c, sisusb)) {
621 mutex_unlock(&sisusb->lock);
622 return -EINVAL;
623 }
624
625 for (i = j = 0; i < 16; i++) {
626 if (sisusb_setreg(sisusb, SISCOLIDX, table[i]))
627 break;
628 if (sisusb_setreg(sisusb, SISCOLDATA, c->vc_palette[j++] >> 2))
629 break;
630 if (sisusb_setreg(sisusb, SISCOLDATA, c->vc_palette[j++] >> 2))
631 break;
632 if (sisusb_setreg(sisusb, SISCOLDATA, c->vc_palette[j++] >> 2))
633 break;
634 }
635
636 mutex_unlock(&sisusb->lock);
637
638 return 0;
639}
640
641/* interface routine */
642static int
643sisusbcon_blank(struct vc_data *c, int blank, int mode_switch)
644{
645 struct sisusb_usb_data *sisusb;
646 u8 sr1, cr17, pmreg, cr63;
647 ssize_t written;
648 int ret = 0;
649
650 sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num);
651 if (!sisusb)
652 return 0;
653
654 /* sisusb->lock is down */
655
656 if (mode_switch)
657 sisusb->is_gfx = blank ? 1 : 0;
658
659 if (sisusb_is_inactive(c, sisusb)) {
660 mutex_unlock(&sisusb->lock);
661 return 0;
662 }
663
664 switch (blank) {
665
666 case 1: /* Normal blanking: Clear screen */
667 case -1:
668 sisusbcon_memsetw((u16 *)c->vc_origin,
669 c->vc_video_erase_char,
670 c->vc_screenbuf_size);
671 sisusb_copy_memory(sisusb,
672 (unsigned char *)c->vc_origin,
673 (u32)(sisusb->vrambase +
674 (c->vc_origin - sisusb->scrbuf)),
675 c->vc_screenbuf_size, &written);
676 sisusb->con_blanked = 1;
677 ret = 1;
678 break;
679
680 default: /* VESA blanking */
681 switch (blank) {
682 case 0: /* Unblank */
683 sr1 = 0x00;
684 cr17 = 0x80;
685 pmreg = 0x00;
686 cr63 = 0x00;
687 ret = 1;
688 sisusb->con_blanked = 0;
689 break;
690 case VESA_VSYNC_SUSPEND + 1:
691 sr1 = 0x20;
692 cr17 = 0x80;
693 pmreg = 0x80;
694 cr63 = 0x40;
695 break;
696 case VESA_HSYNC_SUSPEND + 1:
697 sr1 = 0x20;
698 cr17 = 0x80;
699 pmreg = 0x40;
700 cr63 = 0x40;
701 break;
702 case VESA_POWERDOWN + 1:
703 sr1 = 0x20;
704 cr17 = 0x00;
705 pmreg = 0xc0;
706 cr63 = 0x40;
707 break;
708 default:
709 mutex_unlock(&sisusb->lock);
710 return -EINVAL;
711 }
712
713 sisusb_setidxregandor(sisusb, SISSR, 0x01, ~0x20, sr1);
714 sisusb_setidxregandor(sisusb, SISCR, 0x17, 0x7f, cr17);
715 sisusb_setidxregandor(sisusb, SISSR, 0x1f, 0x3f, pmreg);
716 sisusb_setidxregandor(sisusb, SISCR, 0x63, 0xbf, cr63);
717
718 }
719
720 mutex_unlock(&sisusb->lock);
721
722 return ret;
723}
724
725/* interface routine */
726static int
727sisusbcon_scrolldelta(struct vc_data *c, int lines)
728{
729 struct sisusb_usb_data *sisusb;
730 int margin = c->vc_size_row * 4;
731 int ul, we, p, st;
732
733 /* The return value does not seem to be used */
734
735 sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num);
736 if (!sisusb)
737 return 0;
738
739 /* sisusb->lock is down */
740
741 if (sisusb_is_inactive(c, sisusb)) {
742 mutex_unlock(&sisusb->lock);
743 return 0;
744 }
745
746 if (!lines) /* Turn scrollback off */
747 c->vc_visible_origin = c->vc_origin;
748 else {
749
750 if (sisusb->con_rolled_over >
751 (c->vc_scr_end - sisusb->scrbuf) + margin) {
752
753 ul = c->vc_scr_end - sisusb->scrbuf;
754 we = sisusb->con_rolled_over + c->vc_size_row;
755
756 } else {
757
758 ul = 0;
759 we = sisusb->scrbuf_size;
760
761 }
762
763 p = (c->vc_visible_origin - sisusb->scrbuf - ul + we) % we +
764 lines * c->vc_size_row;
765
766 st = (c->vc_origin - sisusb->scrbuf - ul + we) % we;
767
768 if (st < 2 * margin)
769 margin = 0;
770
771 if (p < margin)
772 p = 0;
773
774 if (p > st - margin)
775 p = st;
776
777 c->vc_visible_origin = sisusb->scrbuf + (p + ul) % we;
778 }
779
780 sisusbcon_set_start_address(sisusb, c);
781
782 mutex_unlock(&sisusb->lock);
783
784 return 1;
785}
786
787/* Interface routine */
788static void
789sisusbcon_cursor(struct vc_data *c, int mode)
790{
791 struct sisusb_usb_data *sisusb;
792 int from, to, baseline;
793
794 sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num);
795 if (!sisusb)
796 return;
797
798 /* sisusb->lock is down */
799
800 if (sisusb_is_inactive(c, sisusb)) {
801 mutex_unlock(&sisusb->lock);
802 return;
803 }
804
805 if (c->vc_origin != c->vc_visible_origin) {
806 c->vc_visible_origin = c->vc_origin;
807 sisusbcon_set_start_address(sisusb, c);
808 }
809
810 if (mode == CM_ERASE) {
811 sisusb_setidxregor(sisusb, SISCR, 0x0a, 0x20);
812 sisusb->sisusb_cursor_size_to = -1;
813 mutex_unlock(&sisusb->lock);
814 return;
815 }
816
817 sisusb_set_cursor(sisusb, (c->vc_pos - sisusb->scrbuf) / 2);
818
819 baseline = c->vc_font.height - (c->vc_font.height < 10 ? 1 : 2);
820
821 switch (c->vc_cursor_type & 0x0f) {
822 case CUR_BLOCK: from = 1;
823 to = c->vc_font.height;
824 break;
825 case CUR_TWO_THIRDS: from = c->vc_font.height / 3;
826 to = baseline;
827 break;
828 case CUR_LOWER_HALF: from = c->vc_font.height / 2;
829 to = baseline;
830 break;
831 case CUR_LOWER_THIRD: from = (c->vc_font.height * 2) / 3;
832 to = baseline;
833 break;
834 case CUR_NONE: from = 31;
835 to = 30;
836 break;
837 default:
838 case CUR_UNDERLINE: from = baseline - 1;
839 to = baseline;
840 break;
841 }
842
843 if (sisusb->sisusb_cursor_size_from != from ||
844 sisusb->sisusb_cursor_size_to != to) {
845
846 sisusb_setidxreg(sisusb, SISCR, 0x0a, from);
847 sisusb_setidxregandor(sisusb, SISCR, 0x0b, 0xe0, to);
848
849 sisusb->sisusb_cursor_size_from = from;
850 sisusb->sisusb_cursor_size_to = to;
851 }
852
853 mutex_unlock(&sisusb->lock);
854}
855
856static int
857sisusbcon_scroll_area(struct vc_data *c, struct sisusb_usb_data *sisusb,
858 int t, int b, int dir, int lines)
859{
860 int cols = sisusb->sisusb_num_columns;
861 int length = ((b - t) * cols) * 2;
862 u16 eattr = c->vc_video_erase_char;
863 ssize_t written;
864
865 /* sisusb->lock is down */
866
867 /* Scroll an area which does not match the
868 * visible screen's dimensions. This needs
869 * to be done separately, as it does not
870 * use hardware panning.
871 */
872
873 switch (dir) {
874
875 case SM_UP:
876 sisusbcon_memmovew(SISUSB_VADDR(0, t),
877 SISUSB_VADDR(0, t + lines),
878 (b - t - lines) * cols * 2);
879 sisusbcon_memsetw(SISUSB_VADDR(0, b - lines), eattr,
880 lines * cols * 2);
881 break;
882
883 case SM_DOWN:
884 sisusbcon_memmovew(SISUSB_VADDR(0, t + lines),
885 SISUSB_VADDR(0, t),
886 (b - t - lines) * cols * 2);
887 sisusbcon_memsetw(SISUSB_VADDR(0, t), eattr,
888 lines * cols * 2);
889 break;
890 }
891
892 sisusb_copy_memory(sisusb, (char *)SISUSB_VADDR(0, t),
893 (long)SISUSB_HADDR(0, t), length, &written);
894
895 mutex_unlock(&sisusb->lock);
896
897 return 1;
898}
899
900/* Interface routine */
901static int
902sisusbcon_scroll(struct vc_data *c, int t, int b, int dir, int lines)
903{
904 struct sisusb_usb_data *sisusb;
905 u16 eattr = c->vc_video_erase_char;
906 ssize_t written;
907 int copyall = 0;
908 unsigned long oldorigin;
909 unsigned int delta = lines * c->vc_size_row;
910 u32 originoffset;
911
912 /* Returning != 0 means we have done the scrolling successfully.
913 * Returning 0 makes vt do the scrolling on its own.
914 * Note that con_scroll is only called if the console is
915 * visible. In that case, the origin should be our buffer,
916 * not the vt's private one.
917 */
918
919 if (!lines)
920 return 1;
921
922 sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num);
923 if (!sisusb)
924 return 0;
925
926 /* sisusb->lock is down */
927
928 if (sisusb_is_inactive(c, sisusb)) {
929 mutex_unlock(&sisusb->lock);
930 return 0;
931 }
932
933 /* Special case */
934 if (t || b != c->vc_rows)
935 return sisusbcon_scroll_area(c, sisusb, t, b, dir, lines);
936
937 if (c->vc_origin != c->vc_visible_origin) {
938 c->vc_visible_origin = c->vc_origin;
939 sisusbcon_set_start_address(sisusb, c);
940 }
941
942 /* limit amount to maximum realistic size */
943 if (lines > c->vc_rows)
944 lines = c->vc_rows;
945
946 oldorigin = c->vc_origin;
947
948 switch (dir) {
949
950 case SM_UP:
951
952 if (c->vc_scr_end + delta >=
953 sisusb->scrbuf + sisusb->scrbuf_size) {
954 sisusbcon_memcpyw((u16 *)sisusb->scrbuf,
955 (u16 *)(oldorigin + delta),
956 c->vc_screenbuf_size - delta);
957 c->vc_origin = sisusb->scrbuf;
958 sisusb->con_rolled_over = oldorigin - sisusb->scrbuf;
959 copyall = 1;
960 } else
961 c->vc_origin += delta;
962
963 sisusbcon_memsetw(
964 (u16 *)(c->vc_origin + c->vc_screenbuf_size - delta),
965 eattr, delta);
966
967 break;
968
969 case SM_DOWN:
970
971 if (oldorigin - delta < sisusb->scrbuf) {
972 sisusbcon_memmovew((u16 *)(sisusb->scrbuf +
973 sisusb->scrbuf_size -
974 c->vc_screenbuf_size +
975 delta),
976 (u16 *)oldorigin,
977 c->vc_screenbuf_size - delta);
978 c->vc_origin = sisusb->scrbuf +
979 sisusb->scrbuf_size -
980 c->vc_screenbuf_size;
981 sisusb->con_rolled_over = 0;
982 copyall = 1;
983 } else
984 c->vc_origin -= delta;
985
986 c->vc_scr_end = c->vc_origin + c->vc_screenbuf_size;
987
988 scr_memsetw((u16 *)(c->vc_origin), eattr, delta);
989
990 break;
991 }
992
993 originoffset = (u32)(c->vc_origin - sisusb->scrbuf);
994
995 if (copyall)
996 sisusb_copy_memory(sisusb,
997 (char *)c->vc_origin,
998 (u32)(sisusb->vrambase + originoffset),
999 c->vc_screenbuf_size, &written);
1000 else if (dir == SM_UP)
1001 sisusb_copy_memory(sisusb,
1002 (char *)c->vc_origin + c->vc_screenbuf_size - delta,
1003 (u32)sisusb->vrambase + originoffset +
1004 c->vc_screenbuf_size - delta,
1005 delta, &written);
1006 else
1007 sisusb_copy_memory(sisusb,
1008 (char *)c->vc_origin,
1009 (u32)(sisusb->vrambase + originoffset),
1010 delta, &written);
1011
1012 c->vc_scr_end = c->vc_origin + c->vc_screenbuf_size;
1013 c->vc_visible_origin = c->vc_origin;
1014
1015 sisusbcon_set_start_address(sisusb, c);
1016
1017 c->vc_pos = c->vc_pos - oldorigin + c->vc_origin;
1018
1019 mutex_unlock(&sisusb->lock);
1020
1021 return 1;
1022}
1023
1024/* Interface routine */
1025static int
1026sisusbcon_set_origin(struct vc_data *c)
1027{
1028 struct sisusb_usb_data *sisusb;
1029
1030 /* Returning != 0 means we were successful.
1031 * Returning 0 will vt make to use its own
1032 * screenbuffer as the origin.
1033 */
1034
1035 sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num);
1036 if (!sisusb)
1037 return 0;
1038
1039 /* sisusb->lock is down */
1040
1041 if (sisusb_is_inactive(c, sisusb) || sisusb->con_blanked) {
1042 mutex_unlock(&sisusb->lock);
1043 return 0;
1044 }
1045
1046 c->vc_origin = c->vc_visible_origin = sisusb->scrbuf;
1047
1048 sisusbcon_set_start_address(sisusb, c);
1049
1050 sisusb->con_rolled_over = 0;
1051
1052 mutex_unlock(&sisusb->lock);
1053
1054 return 1;
1055}
1056
1057/* Interface routine */
1058static int
1059sisusbcon_resize(struct vc_data *c, unsigned int newcols, unsigned int newrows,
1060 unsigned int user)
1061{
1062 struct sisusb_usb_data *sisusb;
1063 int fh;
1064
1065 sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num);
1066 if (!sisusb)
1067 return -ENODEV;
1068
1069 fh = sisusb->current_font_height;
1070
1071 mutex_unlock(&sisusb->lock);
1072
1073 /* We are quite unflexible as regards resizing. The vt code
1074 * handles sizes where the line length isn't equal the pitch
1075 * quite badly. As regards the rows, our panning tricks only
1076 * work well if the number of rows equals the visible number
1077 * of rows.
1078 */
1079
1080 if (newcols != 80 || c->vc_scan_lines / fh != newrows)
1081 return -EINVAL;
1082
1083 return 0;
1084}
1085
1086int
1087sisusbcon_do_font_op(struct sisusb_usb_data *sisusb, int set, int slot,
1088 u8 *arg, int cmapsz, int ch512, int dorecalc,
1089 struct vc_data *c, int fh, int uplock)
1090{
1091 int font_select = 0x00, i, err = 0;
1092 u32 offset = 0;
1093 u8 dummy;
1094
1095 /* sisusb->lock is down */
1096
1097 /*
1098 * The default font is kept in slot 0.
1099 * A user font is loaded in slot 2 (256 ch)
1100 * or 2+3 (512 ch).
1101 */
1102
1103 if ((slot != 0 && slot != 2) || !fh) {
1104 if (uplock)
1105 mutex_unlock(&sisusb->lock);
1106 return -EINVAL;
1107 }
1108
1109 if (set)
1110 sisusb->font_slot = slot;
1111
1112 /* Default font is always 256 */
1113 if (slot == 0)
1114 ch512 = 0;
1115 else
1116 offset = 4 * cmapsz;
1117
1118 font_select = (slot == 0) ? 0x00 : (ch512 ? 0x0e : 0x0a);
1119
1120 err |= sisusb_setidxreg(sisusb, SISSR, 0x00, 0x01); /* Reset */
1121 err |= sisusb_setidxreg(sisusb, SISSR, 0x02, 0x04); /* Write to plane 2 */
1122 err |= sisusb_setidxreg(sisusb, SISSR, 0x04, 0x07); /* Memory mode a0-bf */
1123 err |= sisusb_setidxreg(sisusb, SISSR, 0x00, 0x03); /* Reset */
1124
1125 if (err)
1126 goto font_op_error;
1127
1128 err |= sisusb_setidxreg(sisusb, SISGR, 0x04, 0x03); /* Select plane read 2 */
1129 err |= sisusb_setidxreg(sisusb, SISGR, 0x05, 0x00); /* Disable odd/even */
1130 err |= sisusb_setidxreg(sisusb, SISGR, 0x06, 0x00); /* Address range a0-bf */
1131
1132 if (err)
1133 goto font_op_error;
1134
1135 if (arg) {
1136 if (set)
1137 for (i = 0; i < cmapsz; i++) {
1138 err |= sisusb_writeb(sisusb,
1139 sisusb->vrambase + offset + i,
1140 arg[i]);
1141 if (err)
1142 break;
1143 }
1144 else
1145 for (i = 0; i < cmapsz; i++) {
1146 err |= sisusb_readb(sisusb,
1147 sisusb->vrambase + offset + i,
1148 &arg[i]);
1149 if (err)
1150 break;
1151 }
1152
1153 /*
1154 * In 512-character mode, the character map is not contiguous if
1155 * we want to remain EGA compatible -- which we do
1156 */
1157
1158 if (ch512) {
1159 if (set)
1160 for (i = 0; i < cmapsz; i++) {
1161 err |= sisusb_writeb(sisusb,
1162 sisusb->vrambase + offset +
1163 (2 * cmapsz) + i,
1164 arg[cmapsz + i]);
1165 if (err)
1166 break;
1167 }
1168 else
1169 for (i = 0; i < cmapsz; i++) {
1170 err |= sisusb_readb(sisusb,
1171 sisusb->vrambase + offset +
1172 (2 * cmapsz) + i,
1173 &arg[cmapsz + i]);
1174 if (err)
1175 break;
1176 }
1177 }
1178 }
1179
1180 if (err)
1181 goto font_op_error;
1182
1183 err |= sisusb_setidxreg(sisusb, SISSR, 0x00, 0x01); /* Reset */
1184 err |= sisusb_setidxreg(sisusb, SISSR, 0x02, 0x03); /* Write to planes 0+1 */
1185 err |= sisusb_setidxreg(sisusb, SISSR, 0x04, 0x03); /* Memory mode a0-bf */
1186 if (set)
1187 sisusb_setidxreg(sisusb, SISSR, 0x03, font_select);
1188 err |= sisusb_setidxreg(sisusb, SISSR, 0x00, 0x03); /* Reset end */
1189
1190 if (err)
1191 goto font_op_error;
1192
1193 err |= sisusb_setidxreg(sisusb, SISGR, 0x04, 0x00); /* Select plane read 0 */
1194 err |= sisusb_setidxreg(sisusb, SISGR, 0x05, 0x10); /* Enable odd/even */
1195 err |= sisusb_setidxreg(sisusb, SISGR, 0x06, 0x06); /* Address range b8-bf */
1196
1197 if (err)
1198 goto font_op_error;
1199
1200 if ((set) && (ch512 != sisusb->current_font_512)) {
1201
1202 /* Font is shared among all our consoles.
1203 * And so is the hi_font_mask.
1204 */
1205 for (i = 0; i < MAX_NR_CONSOLES; i++) {
1206 struct vc_data *d = vc_cons[i].d;
1207 if (d && d->vc_sw == &sisusb_con)
1208 d->vc_hi_font_mask = ch512 ? 0x0800 : 0;
1209 }
1210
1211 sisusb->current_font_512 = ch512;
1212
1213 /* color plane enable register:
1214 256-char: enable intensity bit
1215 512-char: disable intensity bit */
1216 sisusb_getreg(sisusb, SISINPSTAT, &dummy);
1217 sisusb_setreg(sisusb, SISAR, 0x12);
1218 sisusb_setreg(sisusb, SISAR, ch512 ? 0x07 : 0x0f);
1219
1220 sisusb_getreg(sisusb, SISINPSTAT, &dummy);
1221 sisusb_setreg(sisusb, SISAR, 0x20);
1222 sisusb_getreg(sisusb, SISINPSTAT, &dummy);
1223 }
1224
1225 if (dorecalc) {
1226
1227 /*
1228 * Adjust the screen to fit a font of a certain height
1229 */
1230
1231 unsigned char ovr, vde, fsr;
1232 int rows = 0, maxscan = 0;
1233
1234 if (c) {
1235
1236 /* Number of video rows */
1237 rows = c->vc_scan_lines / fh;
1238 /* Scan lines to actually display-1 */
1239 maxscan = rows * fh - 1;
1240
1241 /*printk(KERN_DEBUG "sisusb recalc rows %d maxscan %d fh %d sl %d\n",
1242 rows, maxscan, fh, c->vc_scan_lines);*/
1243
1244 sisusb_getidxreg(sisusb, SISCR, 0x07, &ovr);
1245 vde = maxscan & 0xff;
1246 ovr = (ovr & 0xbd) |
1247 ((maxscan & 0x100) >> 7) |
1248 ((maxscan & 0x200) >> 3);
1249 sisusb_setidxreg(sisusb, SISCR, 0x07, ovr);
1250 sisusb_setidxreg(sisusb, SISCR, 0x12, vde);
1251
1252 }
1253
1254 sisusb_getidxreg(sisusb, SISCR, 0x09, &fsr);
1255 fsr = (fsr & 0xe0) | (fh - 1);
1256 sisusb_setidxreg(sisusb, SISCR, 0x09, fsr);
1257 sisusb->current_font_height = fh;
1258
1259 sisusb->sisusb_cursor_size_from = -1;
1260 sisusb->sisusb_cursor_size_to = -1;
1261
1262 }
1263
1264 if (uplock)
1265 mutex_unlock(&sisusb->lock);
1266
1267 if (dorecalc && c) {
1268 int rows = c->vc_scan_lines / fh;
1269
1270 /* Now adjust our consoles' size */
1271
1272 for (i = 0; i < MAX_NR_CONSOLES; i++) {
1273 struct vc_data *vc = vc_cons[i].d;
1274
1275 if (vc && vc->vc_sw == &sisusb_con) {
1276 if (CON_IS_VISIBLE(vc)) {
1277 vc->vc_sw->con_cursor(vc, CM_DRAW);
1278 }
1279 vc->vc_font.height = fh;
1280 vc_resize(vc, 0, rows);
1281 }
1282 }
1283 }
1284
1285 return 0;
1286
1287font_op_error:
1288 if (uplock)
1289 mutex_unlock(&sisusb->lock);
1290
1291 return -EIO;
1292}
1293
1294/* Interface routine */
1295static int
1296sisusbcon_font_set(struct vc_data *c, struct console_font *font,
1297 unsigned flags)
1298{
1299 struct sisusb_usb_data *sisusb;
1300 unsigned charcount = font->charcount;
1301
1302 if (font->width != 8 || (charcount != 256 && charcount != 512))
1303 return -EINVAL;
1304
1305 sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num);
1306 if (!sisusb)
1307 return -ENODEV;
1308
1309 /* sisusb->lock is down */
1310
1311 /* Save the user-provided font into a buffer. This
1312 * is used for restoring text mode after quitting
1313 * from X and for the con_getfont routine.
1314 */
1315 if (sisusb->font_backup) {
1316 if (sisusb->font_backup_size < charcount) {
1317 vfree(sisusb->font_backup);
1318 sisusb->font_backup = NULL;
1319 }
1320 }
1321
1322 if (!sisusb->font_backup)
1323 sisusb->font_backup = vmalloc(charcount * 32);
1324
1325 if (sisusb->font_backup) {
1326 memcpy(sisusb->font_backup, font->data, charcount * 32);
1327 sisusb->font_backup_size = charcount;
1328 sisusb->font_backup_height = font->height;
1329 sisusb->font_backup_512 = (charcount == 512) ? 1 : 0;
1330 }
1331
1332 /* do_font_op ups sisusb->lock */
1333
1334 return sisusbcon_do_font_op(sisusb, 1, 2, font->data,
1335 8192, (charcount == 512),
1336 (!(flags & KD_FONT_FLAG_DONT_RECALC)) ? 1 : 0,
1337 c, font->height, 1);
1338}
1339
1340/* Interface routine */
1341static int
1342sisusbcon_font_get(struct vc_data *c, struct console_font *font)
1343{
1344 struct sisusb_usb_data *sisusb;
1345
1346 sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num);
1347 if (!sisusb)
1348 return -ENODEV;
1349
1350 /* sisusb->lock is down */
1351
1352 font->width = 8;
1353 font->height = c->vc_font.height;
1354 font->charcount = 256;
1355
1356 if (!font->data) {
1357 mutex_unlock(&sisusb->lock);
1358 return 0;
1359 }
1360
1361 if (!sisusb->font_backup) {
1362 mutex_unlock(&sisusb->lock);
1363 return -ENODEV;
1364 }
1365
1366 /* Copy 256 chars only, like vgacon */
1367 memcpy(font->data, sisusb->font_backup, 256 * 32);
1368
1369 mutex_unlock(&sisusb->lock);
1370
1371 return 0;
1372}
1373
1374/*
1375 * The console `switch' structure for the sisusb console
1376 */
1377
1378static const struct consw sisusb_con = {
1379 .owner = THIS_MODULE,
1380 .con_startup = sisusbcon_startup,
1381 .con_init = sisusbcon_init,
1382 .con_deinit = sisusbcon_deinit,
1383 .con_clear = sisusbcon_clear,
1384 .con_putc = sisusbcon_putc,
1385 .con_putcs = sisusbcon_putcs,
1386 .con_cursor = sisusbcon_cursor,
1387 .con_scroll = sisusbcon_scroll,
1388 .con_bmove = sisusbcon_bmove,
1389 .con_switch = sisusbcon_switch,
1390 .con_blank = sisusbcon_blank,
1391 .con_font_set = sisusbcon_font_set,
1392 .con_font_get = sisusbcon_font_get,
1393 .con_set_palette = sisusbcon_set_palette,
1394 .con_scrolldelta = sisusbcon_scrolldelta,
1395 .con_build_attr = sisusbcon_build_attr,
1396 .con_invert_region = sisusbcon_invert_region,
1397 .con_set_origin = sisusbcon_set_origin,
1398 .con_save_screen = sisusbcon_save_screen,
1399 .con_resize = sisusbcon_resize,
1400};
1401
1402/* Our very own dummy console driver */
1403
1404static const char *sisusbdummycon_startup(void)
1405{
1406 return "SISUSBVGADUMMY";
1407}
1408
1409static void sisusbdummycon_init(struct vc_data *vc, int init)
1410{
1411 vc->vc_can_do_color = 1;
1412 if (init) {
1413 vc->vc_cols = 80;
1414 vc->vc_rows = 25;
1415 } else
1416 vc_resize(vc, 80, 25);
1417}
1418
1419static int sisusbdummycon_dummy(void)
1420{
1421 return 0;
1422}
1423
1424#define SISUSBCONDUMMY (void *)sisusbdummycon_dummy
1425
1426static const struct consw sisusb_dummy_con = {
1427 .owner = THIS_MODULE,
1428 .con_startup = sisusbdummycon_startup,
1429 .con_init = sisusbdummycon_init,
1430 .con_deinit = SISUSBCONDUMMY,
1431 .con_clear = SISUSBCONDUMMY,
1432 .con_putc = SISUSBCONDUMMY,
1433 .con_putcs = SISUSBCONDUMMY,
1434 .con_cursor = SISUSBCONDUMMY,
1435 .con_scroll = SISUSBCONDUMMY,
1436 .con_bmove = SISUSBCONDUMMY,
1437 .con_switch = SISUSBCONDUMMY,
1438 .con_blank = SISUSBCONDUMMY,
1439 .con_font_set = SISUSBCONDUMMY,
1440 .con_font_get = SISUSBCONDUMMY,
1441 .con_font_default = SISUSBCONDUMMY,
1442 .con_font_copy = SISUSBCONDUMMY,
1443 .con_set_palette = SISUSBCONDUMMY,
1444 .con_scrolldelta = SISUSBCONDUMMY,
1445};
1446
1447int
1448sisusb_console_init(struct sisusb_usb_data *sisusb, int first, int last)
1449{
1450 int i, ret;
1451
1452 mutex_lock(&sisusb->lock);
1453
1454 /* Erm.. that should not happen */
1455 if (sisusb->haveconsole || !sisusb->SiS_Pr) {
1456 mutex_unlock(&sisusb->lock);
1457 return 1;
1458 }
1459
1460 sisusb->con_first = first;
1461 sisusb->con_last = last;
1462
1463 if (first > last ||
1464 first > MAX_NR_CONSOLES ||
1465 last > MAX_NR_CONSOLES) {
1466 mutex_unlock(&sisusb->lock);
1467 return 1;
1468 }
1469
1470 /* If gfxcore not initialized or no consoles given, quit graciously */
1471 if (!sisusb->gfxinit || first < 1 || last < 1) {
1472 mutex_unlock(&sisusb->lock);
1473 return 0;
1474 }
1475
1476 sisusb->sisusb_cursor_loc = -1;
1477 sisusb->sisusb_cursor_size_from = -1;
1478 sisusb->sisusb_cursor_size_to = -1;
1479
1480 /* Set up text mode (and upload default font) */
1481 if (sisusb_reset_text_mode(sisusb, 1)) {
1482 mutex_unlock(&sisusb->lock);
1483 dev_err(&sisusb->sisusb_dev->dev, "Failed to set up text mode\n");
1484 return 1;
1485 }
1486
1487 /* Initialize some gfx registers */
1488 sisusb_initialize(sisusb);
1489
1490 for (i = first - 1; i <= last - 1; i++) {
1491 /* Save sisusb for our interface routines */
1492 mysisusbs[i] = sisusb;
1493 }
1494
1495 /* Initial console setup */
1496 sisusb->sisusb_num_columns = 80;
1497
1498 /* Use a 32K buffer (matches b8000-bffff area) */
1499 sisusb->scrbuf_size = 32 * 1024;
1500
1501 /* Allocate screen buffer */
1502 if (!(sisusb->scrbuf = (unsigned long)vmalloc(sisusb->scrbuf_size))) {
1503 mutex_unlock(&sisusb->lock);
1504 dev_err(&sisusb->sisusb_dev->dev, "Failed to allocate screen buffer\n");
1505 return 1;
1506 }
1507
1508 mutex_unlock(&sisusb->lock);
1509
1510 /* Now grab the desired console(s) */
1511 console_lock();
1512 ret = do_take_over_console(&sisusb_con, first - 1, last - 1, 0);
1513 console_unlock();
1514 if (!ret)
1515 sisusb->haveconsole = 1;
1516 else {
1517 for (i = first - 1; i <= last - 1; i++)
1518 mysisusbs[i] = NULL;
1519 }
1520
1521 return ret;
1522}
1523
1524void
1525sisusb_console_exit(struct sisusb_usb_data *sisusb)
1526{
1527 int i;
1528
1529 /* This is called if the device is disconnected
1530 * and while disconnect and lock semaphores
1531 * are up. This should be save because we
1532 * can't lose our sisusb any other way but by
1533 * disconnection (and hence, the disconnect
1534 * sema is for protecting all other access
1535 * functions from disconnection, not the
1536 * other way round).
1537 */
1538
1539 /* Now what do we do in case of disconnection:
1540 * One alternative would be to simply call
1541 * give_up_console(). Nah, not a good idea.
1542 * give_up_console() is obviously buggy as it
1543 * only discards the consw pointer from the
1544 * driver_map, but doesn't adapt vc->vc_sw
1545 * of the affected consoles. Hence, the next
1546 * call to any of the console functions will
1547 * eventually take a trip to oops county.
1548 * Also, give_up_console for some reason
1549 * doesn't decrement our module refcount.
1550 * Instead, we switch our consoles to a private
1551 * dummy console. This, of course, keeps our
1552 * refcount up as well, but it works perfectly.
1553 */
1554
1555 if (sisusb->haveconsole) {
1556 for (i = 0; i < MAX_NR_CONSOLES; i++)
1557 if (sisusb->havethisconsole[i]) {
1558 console_lock();
1559 do_take_over_console(&sisusb_dummy_con, i, i, 0);
1560 console_unlock();
1561 /* At this point, con_deinit for all our
1562 * consoles is executed by do_take_over_console().
1563 */
1564 }
1565 sisusb->haveconsole = 0;
1566 }
1567
1568 vfree((void *)sisusb->scrbuf);
1569 sisusb->scrbuf = 0;
1570
1571 vfree(sisusb->font_backup);
1572 sisusb->font_backup = NULL;
1573}
1574
1575void __init sisusb_init_concode(void)
1576{
1577 int i;
1578
1579 for (i = 0; i < MAX_NR_CONSOLES; i++)
1580 mysisusbs[i] = NULL;
1581}
1582
1583#endif /* INCL_CON */
1584
1585
1586
1// SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause)
2/*
3 * sisusb - usb kernel driver for SiS315(E) based USB2VGA dongles
4 *
5 * VGA text mode console part
6 *
7 * Copyright (C) 2005 by Thomas Winischhofer, Vienna, Austria
8 *
9 * If distributed as part of the Linux kernel, this code is licensed under the
10 * terms of the GPL v2.
11 *
12 * Otherwise, the following license terms apply:
13 *
14 * * Redistribution and use in source and binary forms, with or without
15 * * modification, are permitted provided that the following conditions
16 * * are met:
17 * * 1) Redistributions of source code must retain the above copyright
18 * * notice, this list of conditions and the following disclaimer.
19 * * 2) Redistributions in binary form must reproduce the above copyright
20 * * notice, this list of conditions and the following disclaimer in the
21 * * documentation and/or other materials provided with the distribution.
22 * * 3) The name of the author may not be used to endorse or promote products
23 * * derived from this software without specific psisusbr written permission.
24 * *
25 * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESSED OR
26 * * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
27 * * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
28 * * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
29 * * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
30 * * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
31 * * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
32 * * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
33 * * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
34 * * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
35 *
36 * Author: Thomas Winischhofer <thomas@winischhofer.net>
37 *
38 * Portions based on vgacon.c which are
39 * Created 28 Sep 1997 by Geert Uytterhoeven
40 * Rewritten by Martin Mares <mj@ucw.cz>, July 1998
41 * based on code Copyright (C) 1991, 1992 Linus Torvalds
42 * 1995 Jay Estabrook
43 *
44 * A note on using in_atomic() in here: We can't handle console
45 * calls from non-schedulable context due to our USB-dependend
46 * nature. For now, this driver just ignores any calls if it
47 * detects this state.
48 *
49 */
50
51#include <linux/mutex.h>
52#include <linux/module.h>
53#include <linux/kernel.h>
54#include <linux/signal.h>
55#include <linux/fs.h>
56#include <linux/usb.h>
57#include <linux/tty.h>
58#include <linux/console.h>
59#include <linux/string.h>
60#include <linux/kd.h>
61#include <linux/init.h>
62#include <linux/vt_kern.h>
63#include <linux/selection.h>
64#include <linux/spinlock.h>
65#include <linux/kref.h>
66#include <linux/ioport.h>
67#include <linux/interrupt.h>
68#include <linux/vmalloc.h>
69
70#include "sisusb.h"
71#include "sisusb_init.h"
72
73#ifdef INCL_SISUSB_CON
74
75#define sisusbcon_writew(val, addr) (*(addr) = (val))
76#define sisusbcon_readw(addr) (*(addr))
77#define sisusbcon_memmovew(d, s, c) memmove(d, s, c)
78#define sisusbcon_memcpyw(d, s, c) memcpy(d, s, c)
79
80/* vc_data -> sisusb conversion table */
81static struct sisusb_usb_data *mysisusbs[MAX_NR_CONSOLES];
82
83/* Forward declaration */
84static const struct consw sisusb_con;
85
86static inline void
87sisusbcon_memsetw(u16 *s, u16 c, unsigned int count)
88{
89 count /= 2;
90 while (count--)
91 sisusbcon_writew(c, s++);
92}
93
94static inline void
95sisusb_initialize(struct sisusb_usb_data *sisusb)
96{
97 /* Reset cursor and start address */
98 if (sisusb_setidxreg(sisusb, SISCR, 0x0c, 0x00))
99 return;
100 if (sisusb_setidxreg(sisusb, SISCR, 0x0d, 0x00))
101 return;
102 if (sisusb_setidxreg(sisusb, SISCR, 0x0e, 0x00))
103 return;
104 sisusb_setidxreg(sisusb, SISCR, 0x0f, 0x00);
105}
106
107static inline void
108sisusbcon_set_start_address(struct sisusb_usb_data *sisusb, struct vc_data *c)
109{
110 sisusb->cur_start_addr = (c->vc_visible_origin - sisusb->scrbuf) / 2;
111
112 sisusb_setidxreg(sisusb, SISCR, 0x0c, (sisusb->cur_start_addr >> 8));
113 sisusb_setidxreg(sisusb, SISCR, 0x0d, (sisusb->cur_start_addr & 0xff));
114}
115
116void
117sisusb_set_cursor(struct sisusb_usb_data *sisusb, unsigned int location)
118{
119 if (sisusb->sisusb_cursor_loc == location)
120 return;
121
122 sisusb->sisusb_cursor_loc = location;
123
124 /* Hardware bug: Text cursor appears twice or not at all
125 * at some positions. Work around it with the cursor skew
126 * bits.
127 */
128
129 if ((location & 0x0007) == 0x0007) {
130 sisusb->bad_cursor_pos = 1;
131 location--;
132 if (sisusb_setidxregandor(sisusb, SISCR, 0x0b, 0x1f, 0x20))
133 return;
134 } else if (sisusb->bad_cursor_pos) {
135 if (sisusb_setidxregand(sisusb, SISCR, 0x0b, 0x1f))
136 return;
137 sisusb->bad_cursor_pos = 0;
138 }
139
140 if (sisusb_setidxreg(sisusb, SISCR, 0x0e, (location >> 8)))
141 return;
142 sisusb_setidxreg(sisusb, SISCR, 0x0f, (location & 0xff));
143}
144
145static inline struct sisusb_usb_data *
146sisusb_get_sisusb(unsigned short console)
147{
148 return mysisusbs[console];
149}
150
151static inline int
152sisusb_sisusb_valid(struct sisusb_usb_data *sisusb)
153{
154 if (!sisusb->present || !sisusb->ready || !sisusb->sisusb_dev)
155 return 0;
156
157 return 1;
158}
159
160static struct sisusb_usb_data *
161sisusb_get_sisusb_lock_and_check(unsigned short console)
162{
163 struct sisusb_usb_data *sisusb;
164
165 /* We can't handle console calls in non-schedulable
166 * context due to our locks and the USB transport.
167 * So we simply ignore them. This should only affect
168 * some calls to printk.
169 */
170 if (in_atomic())
171 return NULL;
172
173 sisusb = sisusb_get_sisusb(console);
174 if (!sisusb)
175 return NULL;
176
177 mutex_lock(&sisusb->lock);
178
179 if (!sisusb_sisusb_valid(sisusb) ||
180 !sisusb->havethisconsole[console]) {
181 mutex_unlock(&sisusb->lock);
182 return NULL;
183 }
184
185 return sisusb;
186}
187
188static int
189sisusb_is_inactive(struct vc_data *c, struct sisusb_usb_data *sisusb)
190{
191 if (sisusb->is_gfx ||
192 sisusb->textmodedestroyed ||
193 c->vc_mode != KD_TEXT)
194 return 1;
195
196 return 0;
197}
198
199/* con_startup console interface routine */
200static const char *
201sisusbcon_startup(void)
202{
203 return "SISUSBCON";
204}
205
206/* con_init console interface routine */
207static void
208sisusbcon_init(struct vc_data *c, int init)
209{
210 struct sisusb_usb_data *sisusb;
211 int cols, rows;
212
213 /* This is called by do_take_over_console(),
214 * ie by us/under our control. It is
215 * only called after text mode and fonts
216 * are set up/restored.
217 */
218
219 sisusb = sisusb_get_sisusb(c->vc_num);
220 if (!sisusb)
221 return;
222
223 mutex_lock(&sisusb->lock);
224
225 if (!sisusb_sisusb_valid(sisusb)) {
226 mutex_unlock(&sisusb->lock);
227 return;
228 }
229
230 c->vc_can_do_color = 1;
231
232 c->vc_complement_mask = 0x7700;
233
234 c->vc_hi_font_mask = sisusb->current_font_512 ? 0x0800 : 0;
235
236 sisusb->haveconsole = 1;
237
238 sisusb->havethisconsole[c->vc_num] = 1;
239
240 /* We only support 640x400 */
241 c->vc_scan_lines = 400;
242
243 c->vc_font.height = sisusb->current_font_height;
244
245 /* We only support width = 8 */
246 cols = 80;
247 rows = c->vc_scan_lines / c->vc_font.height;
248
249 /* Increment usage count for our sisusb.
250 * Doing so saves us from upping/downing
251 * the disconnect semaphore; we can't
252 * lose our sisusb until this is undone
253 * in con_deinit. For all other console
254 * interface functions, it suffices to
255 * use sisusb->lock and do a quick check
256 * of sisusb for device disconnection.
257 */
258 kref_get(&sisusb->kref);
259
260 if (!*c->vc_uni_pagedir_loc)
261 con_set_default_unimap(c);
262
263 mutex_unlock(&sisusb->lock);
264
265 if (init) {
266 c->vc_cols = cols;
267 c->vc_rows = rows;
268 } else
269 vc_resize(c, cols, rows);
270}
271
272/* con_deinit console interface routine */
273static void
274sisusbcon_deinit(struct vc_data *c)
275{
276 struct sisusb_usb_data *sisusb;
277 int i;
278
279 /* This is called by do_take_over_console()
280 * and others, ie not under our control.
281 */
282
283 sisusb = sisusb_get_sisusb(c->vc_num);
284 if (!sisusb)
285 return;
286
287 mutex_lock(&sisusb->lock);
288
289 /* Clear ourselves in mysisusbs */
290 mysisusbs[c->vc_num] = NULL;
291
292 sisusb->havethisconsole[c->vc_num] = 0;
293
294 /* Free our font buffer if all consoles are gone */
295 if (sisusb->font_backup) {
296 for(i = 0; i < MAX_NR_CONSOLES; i++) {
297 if (sisusb->havethisconsole[c->vc_num])
298 break;
299 }
300 if (i == MAX_NR_CONSOLES) {
301 vfree(sisusb->font_backup);
302 sisusb->font_backup = NULL;
303 }
304 }
305
306 mutex_unlock(&sisusb->lock);
307
308 /* decrement the usage count on our sisusb */
309 kref_put(&sisusb->kref, sisusb_delete);
310}
311
312/* interface routine */
313static u8
314sisusbcon_build_attr(struct vc_data *c, u8 color, u8 intensity,
315 u8 blink, u8 underline, u8 reverse, u8 unused)
316{
317 u8 attr = color;
318
319 if (underline)
320 attr = (attr & 0xf0) | c->vc_ulcolor;
321 else if (intensity == 0)
322 attr = (attr & 0xf0) | c->vc_halfcolor;
323
324 if (reverse)
325 attr = ((attr) & 0x88) |
326 ((((attr) >> 4) |
327 ((attr) << 4)) & 0x77);
328
329 if (blink)
330 attr ^= 0x80;
331
332 if (intensity == 2)
333 attr ^= 0x08;
334
335 return attr;
336}
337
338/* Interface routine */
339static void
340sisusbcon_invert_region(struct vc_data *vc, u16 *p, int count)
341{
342 /* Invert a region. This is called with a pointer
343 * to the console's internal screen buffer. So we
344 * simply do the inversion there and rely on
345 * a call to putc(s) to update the real screen.
346 */
347
348 while (count--) {
349 u16 a = sisusbcon_readw(p);
350
351 a = ((a) & 0x88ff) |
352 (((a) & 0x7000) >> 4) |
353 (((a) & 0x0700) << 4);
354
355 sisusbcon_writew(a, p++);
356 }
357}
358
359#define SISUSB_VADDR(x,y) \
360 ((u16 *)c->vc_origin + \
361 (y) * sisusb->sisusb_num_columns + \
362 (x))
363
364#define SISUSB_HADDR(x,y) \
365 ((u16 *)(sisusb->vrambase + (c->vc_origin - sisusb->scrbuf)) + \
366 (y) * sisusb->sisusb_num_columns + \
367 (x))
368
369/* Interface routine */
370static void
371sisusbcon_putc(struct vc_data *c, int ch, int y, int x)
372{
373 struct sisusb_usb_data *sisusb;
374
375 sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num);
376 if (!sisusb)
377 return;
378
379 /* sisusb->lock is down */
380 if (sisusb_is_inactive(c, sisusb)) {
381 mutex_unlock(&sisusb->lock);
382 return;
383 }
384
385
386 sisusb_copy_memory(sisusb, (char *)SISUSB_VADDR(x, y),
387 (long)SISUSB_HADDR(x, y), 2);
388
389 mutex_unlock(&sisusb->lock);
390}
391
392/* Interface routine */
393static void
394sisusbcon_putcs(struct vc_data *c, const unsigned short *s,
395 int count, int y, int x)
396{
397 struct sisusb_usb_data *sisusb;
398 u16 *dest;
399 int i;
400
401 sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num);
402 if (!sisusb)
403 return;
404
405 /* sisusb->lock is down */
406
407 /* Need to put the characters into the buffer ourselves,
408 * because the vt does this AFTER calling us.
409 */
410
411 dest = SISUSB_VADDR(x, y);
412
413 for (i = count; i > 0; i--)
414 sisusbcon_writew(sisusbcon_readw(s++), dest++);
415
416 if (sisusb_is_inactive(c, sisusb)) {
417 mutex_unlock(&sisusb->lock);
418 return;
419 }
420
421 sisusb_copy_memory(sisusb, (char *)SISUSB_VADDR(x, y),
422 (long)SISUSB_HADDR(x, y), count * 2);
423
424 mutex_unlock(&sisusb->lock);
425}
426
427/* Interface routine */
428static void
429sisusbcon_clear(struct vc_data *c, int y, int x, int height, int width)
430{
431 struct sisusb_usb_data *sisusb;
432 u16 eattr = c->vc_video_erase_char;
433 int i, length, cols;
434 u16 *dest;
435
436 if (width <= 0 || height <= 0)
437 return;
438
439 sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num);
440 if (!sisusb)
441 return;
442
443 /* sisusb->lock is down */
444
445 /* Need to clear buffer ourselves, because the vt does
446 * this AFTER calling us.
447 */
448
449 dest = SISUSB_VADDR(x, y);
450
451 cols = sisusb->sisusb_num_columns;
452
453 if (width > cols)
454 width = cols;
455
456 if (x == 0 && width >= c->vc_cols) {
457
458 sisusbcon_memsetw(dest, eattr, height * cols * 2);
459
460 } else {
461
462 for (i = height; i > 0; i--, dest += cols)
463 sisusbcon_memsetw(dest, eattr, width * 2);
464
465 }
466
467 if (sisusb_is_inactive(c, sisusb)) {
468 mutex_unlock(&sisusb->lock);
469 return;
470 }
471
472 length = ((height * cols) - x - (cols - width - x)) * 2;
473
474
475 sisusb_copy_memory(sisusb, (unsigned char *)SISUSB_VADDR(x, y),
476 (long)SISUSB_HADDR(x, y), length);
477
478 mutex_unlock(&sisusb->lock);
479}
480
481/* interface routine */
482static int
483sisusbcon_switch(struct vc_data *c)
484{
485 struct sisusb_usb_data *sisusb;
486 int length;
487
488 /* Returnvalue 0 means we have fully restored screen,
489 * and vt doesn't need to call do_update_region().
490 * Returnvalue != 0 naturally means the opposite.
491 */
492
493 sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num);
494 if (!sisusb)
495 return 0;
496
497 /* sisusb->lock is down */
498
499 /* Don't write to screen if in gfx mode */
500 if (sisusb_is_inactive(c, sisusb)) {
501 mutex_unlock(&sisusb->lock);
502 return 0;
503 }
504
505 /* That really should not happen. It would mean we are
506 * being called while the vc is using its private buffer
507 * as origin.
508 */
509 if (c->vc_origin == (unsigned long)c->vc_screenbuf) {
510 mutex_unlock(&sisusb->lock);
511 dev_dbg(&sisusb->sisusb_dev->dev, "ASSERT ORIGIN != SCREENBUF!\n");
512 return 0;
513 }
514
515 /* Check that we don't copy too much */
516 length = min((int)c->vc_screenbuf_size,
517 (int)(sisusb->scrbuf + sisusb->scrbuf_size - c->vc_origin));
518
519 /* Restore the screen contents */
520 sisusbcon_memcpyw((u16 *)c->vc_origin, (u16 *)c->vc_screenbuf,
521 length);
522
523 sisusb_copy_memory(sisusb, (unsigned char *)c->vc_origin,
524 (long)SISUSB_HADDR(0, 0),
525 length);
526
527 mutex_unlock(&sisusb->lock);
528
529 return 0;
530}
531
532/* interface routine */
533static void
534sisusbcon_save_screen(struct vc_data *c)
535{
536 struct sisusb_usb_data *sisusb;
537 int length;
538
539 /* Save the current screen contents to vc's private
540 * buffer.
541 */
542
543 sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num);
544 if (!sisusb)
545 return;
546
547 /* sisusb->lock is down */
548
549 if (sisusb_is_inactive(c, sisusb)) {
550 mutex_unlock(&sisusb->lock);
551 return;
552 }
553
554 /* Check that we don't copy too much */
555 length = min((int)c->vc_screenbuf_size,
556 (int)(sisusb->scrbuf + sisusb->scrbuf_size - c->vc_origin));
557
558 /* Save the screen contents to vc's private buffer */
559 sisusbcon_memcpyw((u16 *)c->vc_screenbuf, (u16 *)c->vc_origin,
560 length);
561
562 mutex_unlock(&sisusb->lock);
563}
564
565/* interface routine */
566static void
567sisusbcon_set_palette(struct vc_data *c, const unsigned char *table)
568{
569 struct sisusb_usb_data *sisusb;
570 int i, j;
571
572 /* Return value not used by vt */
573
574 if (!con_is_visible(c))
575 return;
576
577 sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num);
578 if (!sisusb)
579 return;
580
581 /* sisusb->lock is down */
582
583 if (sisusb_is_inactive(c, sisusb)) {
584 mutex_unlock(&sisusb->lock);
585 return;
586 }
587
588 for (i = j = 0; i < 16; i++) {
589 if (sisusb_setreg(sisusb, SISCOLIDX, table[i]))
590 break;
591 if (sisusb_setreg(sisusb, SISCOLDATA, c->vc_palette[j++] >> 2))
592 break;
593 if (sisusb_setreg(sisusb, SISCOLDATA, c->vc_palette[j++] >> 2))
594 break;
595 if (sisusb_setreg(sisusb, SISCOLDATA, c->vc_palette[j++] >> 2))
596 break;
597 }
598
599 mutex_unlock(&sisusb->lock);
600}
601
602/* interface routine */
603static int
604sisusbcon_blank(struct vc_data *c, int blank, int mode_switch)
605{
606 struct sisusb_usb_data *sisusb;
607 u8 sr1, cr17, pmreg, cr63;
608 int ret = 0;
609
610 sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num);
611 if (!sisusb)
612 return 0;
613
614 /* sisusb->lock is down */
615
616 if (mode_switch)
617 sisusb->is_gfx = blank ? 1 : 0;
618
619 if (sisusb_is_inactive(c, sisusb)) {
620 mutex_unlock(&sisusb->lock);
621 return 0;
622 }
623
624 switch (blank) {
625
626 case 1: /* Normal blanking: Clear screen */
627 case -1:
628 sisusbcon_memsetw((u16 *)c->vc_origin,
629 c->vc_video_erase_char,
630 c->vc_screenbuf_size);
631 sisusb_copy_memory(sisusb,
632 (unsigned char *)c->vc_origin,
633 (u32)(sisusb->vrambase +
634 (c->vc_origin - sisusb->scrbuf)),
635 c->vc_screenbuf_size);
636 sisusb->con_blanked = 1;
637 ret = 1;
638 break;
639
640 default: /* VESA blanking */
641 switch (blank) {
642 case 0: /* Unblank */
643 sr1 = 0x00;
644 cr17 = 0x80;
645 pmreg = 0x00;
646 cr63 = 0x00;
647 ret = 1;
648 sisusb->con_blanked = 0;
649 break;
650 case VESA_VSYNC_SUSPEND + 1:
651 sr1 = 0x20;
652 cr17 = 0x80;
653 pmreg = 0x80;
654 cr63 = 0x40;
655 break;
656 case VESA_HSYNC_SUSPEND + 1:
657 sr1 = 0x20;
658 cr17 = 0x80;
659 pmreg = 0x40;
660 cr63 = 0x40;
661 break;
662 case VESA_POWERDOWN + 1:
663 sr1 = 0x20;
664 cr17 = 0x00;
665 pmreg = 0xc0;
666 cr63 = 0x40;
667 break;
668 default:
669 mutex_unlock(&sisusb->lock);
670 return -EINVAL;
671 }
672
673 sisusb_setidxregandor(sisusb, SISSR, 0x01, ~0x20, sr1);
674 sisusb_setidxregandor(sisusb, SISCR, 0x17, 0x7f, cr17);
675 sisusb_setidxregandor(sisusb, SISSR, 0x1f, 0x3f, pmreg);
676 sisusb_setidxregandor(sisusb, SISCR, 0x63, 0xbf, cr63);
677
678 }
679
680 mutex_unlock(&sisusb->lock);
681
682 return ret;
683}
684
685/* interface routine */
686static void
687sisusbcon_scrolldelta(struct vc_data *c, int lines)
688{
689 struct sisusb_usb_data *sisusb;
690
691 sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num);
692 if (!sisusb)
693 return;
694
695 /* sisusb->lock is down */
696
697 if (sisusb_is_inactive(c, sisusb)) {
698 mutex_unlock(&sisusb->lock);
699 return;
700 }
701
702 vc_scrolldelta_helper(c, lines, sisusb->con_rolled_over,
703 (void *)sisusb->scrbuf, sisusb->scrbuf_size);
704
705 sisusbcon_set_start_address(sisusb, c);
706
707 mutex_unlock(&sisusb->lock);
708}
709
710/* Interface routine */
711static void
712sisusbcon_cursor(struct vc_data *c, int mode)
713{
714 struct sisusb_usb_data *sisusb;
715 int from, to, baseline;
716
717 sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num);
718 if (!sisusb)
719 return;
720
721 /* sisusb->lock is down */
722
723 if (sisusb_is_inactive(c, sisusb)) {
724 mutex_unlock(&sisusb->lock);
725 return;
726 }
727
728 if (c->vc_origin != c->vc_visible_origin) {
729 c->vc_visible_origin = c->vc_origin;
730 sisusbcon_set_start_address(sisusb, c);
731 }
732
733 if (mode == CM_ERASE) {
734 sisusb_setidxregor(sisusb, SISCR, 0x0a, 0x20);
735 sisusb->sisusb_cursor_size_to = -1;
736 mutex_unlock(&sisusb->lock);
737 return;
738 }
739
740 sisusb_set_cursor(sisusb, (c->vc_pos - sisusb->scrbuf) / 2);
741
742 baseline = c->vc_font.height - (c->vc_font.height < 10 ? 1 : 2);
743
744 switch (c->vc_cursor_type & 0x0f) {
745 case CUR_BLOCK: from = 1;
746 to = c->vc_font.height;
747 break;
748 case CUR_TWO_THIRDS: from = c->vc_font.height / 3;
749 to = baseline;
750 break;
751 case CUR_LOWER_HALF: from = c->vc_font.height / 2;
752 to = baseline;
753 break;
754 case CUR_LOWER_THIRD: from = (c->vc_font.height * 2) / 3;
755 to = baseline;
756 break;
757 case CUR_NONE: from = 31;
758 to = 30;
759 break;
760 default:
761 case CUR_UNDERLINE: from = baseline - 1;
762 to = baseline;
763 break;
764 }
765
766 if (sisusb->sisusb_cursor_size_from != from ||
767 sisusb->sisusb_cursor_size_to != to) {
768
769 sisusb_setidxreg(sisusb, SISCR, 0x0a, from);
770 sisusb_setidxregandor(sisusb, SISCR, 0x0b, 0xe0, to);
771
772 sisusb->sisusb_cursor_size_from = from;
773 sisusb->sisusb_cursor_size_to = to;
774 }
775
776 mutex_unlock(&sisusb->lock);
777}
778
779static bool
780sisusbcon_scroll_area(struct vc_data *c, struct sisusb_usb_data *sisusb,
781 unsigned int t, unsigned int b, enum con_scroll dir,
782 unsigned int lines)
783{
784 int cols = sisusb->sisusb_num_columns;
785 int length = ((b - t) * cols) * 2;
786 u16 eattr = c->vc_video_erase_char;
787
788 /* sisusb->lock is down */
789
790 /* Scroll an area which does not match the
791 * visible screen's dimensions. This needs
792 * to be done separately, as it does not
793 * use hardware panning.
794 */
795
796 switch (dir) {
797
798 case SM_UP:
799 sisusbcon_memmovew(SISUSB_VADDR(0, t),
800 SISUSB_VADDR(0, t + lines),
801 (b - t - lines) * cols * 2);
802 sisusbcon_memsetw(SISUSB_VADDR(0, b - lines), eattr,
803 lines * cols * 2);
804 break;
805
806 case SM_DOWN:
807 sisusbcon_memmovew(SISUSB_VADDR(0, t + lines),
808 SISUSB_VADDR(0, t),
809 (b - t - lines) * cols * 2);
810 sisusbcon_memsetw(SISUSB_VADDR(0, t), eattr,
811 lines * cols * 2);
812 break;
813 }
814
815 sisusb_copy_memory(sisusb, (char *)SISUSB_VADDR(0, t),
816 (long)SISUSB_HADDR(0, t), length);
817
818 mutex_unlock(&sisusb->lock);
819
820 return true;
821}
822
823/* Interface routine */
824static bool
825sisusbcon_scroll(struct vc_data *c, unsigned int t, unsigned int b,
826 enum con_scroll dir, unsigned int lines)
827{
828 struct sisusb_usb_data *sisusb;
829 u16 eattr = c->vc_video_erase_char;
830 int copyall = 0;
831 unsigned long oldorigin;
832 unsigned int delta = lines * c->vc_size_row;
833 u32 originoffset;
834
835 /* Returning != 0 means we have done the scrolling successfully.
836 * Returning 0 makes vt do the scrolling on its own.
837 * Note that con_scroll is only called if the console is
838 * visible. In that case, the origin should be our buffer,
839 * not the vt's private one.
840 */
841
842 if (!lines)
843 return true;
844
845 sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num);
846 if (!sisusb)
847 return false;
848
849 /* sisusb->lock is down */
850
851 if (sisusb_is_inactive(c, sisusb)) {
852 mutex_unlock(&sisusb->lock);
853 return false;
854 }
855
856 /* Special case */
857 if (t || b != c->vc_rows)
858 return sisusbcon_scroll_area(c, sisusb, t, b, dir, lines);
859
860 if (c->vc_origin != c->vc_visible_origin) {
861 c->vc_visible_origin = c->vc_origin;
862 sisusbcon_set_start_address(sisusb, c);
863 }
864
865 /* limit amount to maximum realistic size */
866 if (lines > c->vc_rows)
867 lines = c->vc_rows;
868
869 oldorigin = c->vc_origin;
870
871 switch (dir) {
872
873 case SM_UP:
874
875 if (c->vc_scr_end + delta >=
876 sisusb->scrbuf + sisusb->scrbuf_size) {
877 sisusbcon_memcpyw((u16 *)sisusb->scrbuf,
878 (u16 *)(oldorigin + delta),
879 c->vc_screenbuf_size - delta);
880 c->vc_origin = sisusb->scrbuf;
881 sisusb->con_rolled_over = oldorigin - sisusb->scrbuf;
882 copyall = 1;
883 } else
884 c->vc_origin += delta;
885
886 sisusbcon_memsetw(
887 (u16 *)(c->vc_origin + c->vc_screenbuf_size - delta),
888 eattr, delta);
889
890 break;
891
892 case SM_DOWN:
893
894 if (oldorigin - delta < sisusb->scrbuf) {
895 sisusbcon_memmovew((u16 *)(sisusb->scrbuf +
896 sisusb->scrbuf_size -
897 c->vc_screenbuf_size +
898 delta),
899 (u16 *)oldorigin,
900 c->vc_screenbuf_size - delta);
901 c->vc_origin = sisusb->scrbuf +
902 sisusb->scrbuf_size -
903 c->vc_screenbuf_size;
904 sisusb->con_rolled_over = 0;
905 copyall = 1;
906 } else
907 c->vc_origin -= delta;
908
909 c->vc_scr_end = c->vc_origin + c->vc_screenbuf_size;
910
911 scr_memsetw((u16 *)(c->vc_origin), eattr, delta);
912
913 break;
914 }
915
916 originoffset = (u32)(c->vc_origin - sisusb->scrbuf);
917
918 if (copyall)
919 sisusb_copy_memory(sisusb,
920 (char *)c->vc_origin,
921 (u32)(sisusb->vrambase + originoffset),
922 c->vc_screenbuf_size);
923 else if (dir == SM_UP)
924 sisusb_copy_memory(sisusb,
925 (char *)c->vc_origin + c->vc_screenbuf_size - delta,
926 (u32)sisusb->vrambase + originoffset +
927 c->vc_screenbuf_size - delta,
928 delta);
929 else
930 sisusb_copy_memory(sisusb,
931 (char *)c->vc_origin,
932 (u32)(sisusb->vrambase + originoffset),
933 delta);
934
935 c->vc_scr_end = c->vc_origin + c->vc_screenbuf_size;
936 c->vc_visible_origin = c->vc_origin;
937
938 sisusbcon_set_start_address(sisusb, c);
939
940 c->vc_pos = c->vc_pos - oldorigin + c->vc_origin;
941
942 mutex_unlock(&sisusb->lock);
943
944 return true;
945}
946
947/* Interface routine */
948static int
949sisusbcon_set_origin(struct vc_data *c)
950{
951 struct sisusb_usb_data *sisusb;
952
953 /* Returning != 0 means we were successful.
954 * Returning 0 will vt make to use its own
955 * screenbuffer as the origin.
956 */
957
958 sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num);
959 if (!sisusb)
960 return 0;
961
962 /* sisusb->lock is down */
963
964 if (sisusb_is_inactive(c, sisusb) || sisusb->con_blanked) {
965 mutex_unlock(&sisusb->lock);
966 return 0;
967 }
968
969 c->vc_origin = c->vc_visible_origin = sisusb->scrbuf;
970
971 sisusbcon_set_start_address(sisusb, c);
972
973 sisusb->con_rolled_over = 0;
974
975 mutex_unlock(&sisusb->lock);
976
977 return true;
978}
979
980/* Interface routine */
981static int
982sisusbcon_resize(struct vc_data *c, unsigned int newcols, unsigned int newrows,
983 unsigned int user)
984{
985 struct sisusb_usb_data *sisusb;
986 int fh;
987
988 sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num);
989 if (!sisusb)
990 return -ENODEV;
991
992 fh = sisusb->current_font_height;
993
994 mutex_unlock(&sisusb->lock);
995
996 /* We are quite unflexible as regards resizing. The vt code
997 * handles sizes where the line length isn't equal the pitch
998 * quite badly. As regards the rows, our panning tricks only
999 * work well if the number of rows equals the visible number
1000 * of rows.
1001 */
1002
1003 if (newcols != 80 || c->vc_scan_lines / fh != newrows)
1004 return -EINVAL;
1005
1006 return 0;
1007}
1008
1009int
1010sisusbcon_do_font_op(struct sisusb_usb_data *sisusb, int set, int slot,
1011 u8 *arg, int cmapsz, int ch512, int dorecalc,
1012 struct vc_data *c, int fh, int uplock)
1013{
1014 int font_select = 0x00, i, err = 0;
1015 u32 offset = 0;
1016 u8 dummy;
1017
1018 /* sisusb->lock is down */
1019
1020 /*
1021 * The default font is kept in slot 0.
1022 * A user font is loaded in slot 2 (256 ch)
1023 * or 2+3 (512 ch).
1024 */
1025
1026 if ((slot != 0 && slot != 2) || !fh) {
1027 if (uplock)
1028 mutex_unlock(&sisusb->lock);
1029 return -EINVAL;
1030 }
1031
1032 if (set)
1033 sisusb->font_slot = slot;
1034
1035 /* Default font is always 256 */
1036 if (slot == 0)
1037 ch512 = 0;
1038 else
1039 offset = 4 * cmapsz;
1040
1041 font_select = (slot == 0) ? 0x00 : (ch512 ? 0x0e : 0x0a);
1042
1043 err |= sisusb_setidxreg(sisusb, SISSR, 0x00, 0x01); /* Reset */
1044 err |= sisusb_setidxreg(sisusb, SISSR, 0x02, 0x04); /* Write to plane 2 */
1045 err |= sisusb_setidxreg(sisusb, SISSR, 0x04, 0x07); /* Memory mode a0-bf */
1046 err |= sisusb_setidxreg(sisusb, SISSR, 0x00, 0x03); /* Reset */
1047
1048 if (err)
1049 goto font_op_error;
1050
1051 err |= sisusb_setidxreg(sisusb, SISGR, 0x04, 0x03); /* Select plane read 2 */
1052 err |= sisusb_setidxreg(sisusb, SISGR, 0x05, 0x00); /* Disable odd/even */
1053 err |= sisusb_setidxreg(sisusb, SISGR, 0x06, 0x00); /* Address range a0-bf */
1054
1055 if (err)
1056 goto font_op_error;
1057
1058 if (arg) {
1059 if (set)
1060 for (i = 0; i < cmapsz; i++) {
1061 err |= sisusb_writeb(sisusb,
1062 sisusb->vrambase + offset + i,
1063 arg[i]);
1064 if (err)
1065 break;
1066 }
1067 else
1068 for (i = 0; i < cmapsz; i++) {
1069 err |= sisusb_readb(sisusb,
1070 sisusb->vrambase + offset + i,
1071 &arg[i]);
1072 if (err)
1073 break;
1074 }
1075
1076 /*
1077 * In 512-character mode, the character map is not contiguous if
1078 * we want to remain EGA compatible -- which we do
1079 */
1080
1081 if (ch512) {
1082 if (set)
1083 for (i = 0; i < cmapsz; i++) {
1084 err |= sisusb_writeb(sisusb,
1085 sisusb->vrambase + offset +
1086 (2 * cmapsz) + i,
1087 arg[cmapsz + i]);
1088 if (err)
1089 break;
1090 }
1091 else
1092 for (i = 0; i < cmapsz; i++) {
1093 err |= sisusb_readb(sisusb,
1094 sisusb->vrambase + offset +
1095 (2 * cmapsz) + i,
1096 &arg[cmapsz + i]);
1097 if (err)
1098 break;
1099 }
1100 }
1101 }
1102
1103 if (err)
1104 goto font_op_error;
1105
1106 err |= sisusb_setidxreg(sisusb, SISSR, 0x00, 0x01); /* Reset */
1107 err |= sisusb_setidxreg(sisusb, SISSR, 0x02, 0x03); /* Write to planes 0+1 */
1108 err |= sisusb_setidxreg(sisusb, SISSR, 0x04, 0x03); /* Memory mode a0-bf */
1109 if (set)
1110 sisusb_setidxreg(sisusb, SISSR, 0x03, font_select);
1111 err |= sisusb_setidxreg(sisusb, SISSR, 0x00, 0x03); /* Reset end */
1112
1113 if (err)
1114 goto font_op_error;
1115
1116 err |= sisusb_setidxreg(sisusb, SISGR, 0x04, 0x00); /* Select plane read 0 */
1117 err |= sisusb_setidxreg(sisusb, SISGR, 0x05, 0x10); /* Enable odd/even */
1118 err |= sisusb_setidxreg(sisusb, SISGR, 0x06, 0x06); /* Address range b8-bf */
1119
1120 if (err)
1121 goto font_op_error;
1122
1123 if ((set) && (ch512 != sisusb->current_font_512)) {
1124
1125 /* Font is shared among all our consoles.
1126 * And so is the hi_font_mask.
1127 */
1128 for (i = 0; i < MAX_NR_CONSOLES; i++) {
1129 struct vc_data *d = vc_cons[i].d;
1130 if (d && d->vc_sw == &sisusb_con)
1131 d->vc_hi_font_mask = ch512 ? 0x0800 : 0;
1132 }
1133
1134 sisusb->current_font_512 = ch512;
1135
1136 /* color plane enable register:
1137 256-char: enable intensity bit
1138 512-char: disable intensity bit */
1139 sisusb_getreg(sisusb, SISINPSTAT, &dummy);
1140 sisusb_setreg(sisusb, SISAR, 0x12);
1141 sisusb_setreg(sisusb, SISAR, ch512 ? 0x07 : 0x0f);
1142
1143 sisusb_getreg(sisusb, SISINPSTAT, &dummy);
1144 sisusb_setreg(sisusb, SISAR, 0x20);
1145 sisusb_getreg(sisusb, SISINPSTAT, &dummy);
1146 }
1147
1148 if (dorecalc) {
1149
1150 /*
1151 * Adjust the screen to fit a font of a certain height
1152 */
1153
1154 unsigned char ovr, vde, fsr;
1155 int rows = 0, maxscan = 0;
1156
1157 if (c) {
1158
1159 /* Number of video rows */
1160 rows = c->vc_scan_lines / fh;
1161 /* Scan lines to actually display-1 */
1162 maxscan = rows * fh - 1;
1163
1164 /*printk(KERN_DEBUG "sisusb recalc rows %d maxscan %d fh %d sl %d\n",
1165 rows, maxscan, fh, c->vc_scan_lines);*/
1166
1167 sisusb_getidxreg(sisusb, SISCR, 0x07, &ovr);
1168 vde = maxscan & 0xff;
1169 ovr = (ovr & 0xbd) |
1170 ((maxscan & 0x100) >> 7) |
1171 ((maxscan & 0x200) >> 3);
1172 sisusb_setidxreg(sisusb, SISCR, 0x07, ovr);
1173 sisusb_setidxreg(sisusb, SISCR, 0x12, vde);
1174
1175 }
1176
1177 sisusb_getidxreg(sisusb, SISCR, 0x09, &fsr);
1178 fsr = (fsr & 0xe0) | (fh - 1);
1179 sisusb_setidxreg(sisusb, SISCR, 0x09, fsr);
1180 sisusb->current_font_height = fh;
1181
1182 sisusb->sisusb_cursor_size_from = -1;
1183 sisusb->sisusb_cursor_size_to = -1;
1184
1185 }
1186
1187 if (uplock)
1188 mutex_unlock(&sisusb->lock);
1189
1190 if (dorecalc && c) {
1191 int rows = c->vc_scan_lines / fh;
1192
1193 /* Now adjust our consoles' size */
1194
1195 for (i = 0; i < MAX_NR_CONSOLES; i++) {
1196 struct vc_data *vc = vc_cons[i].d;
1197
1198 if (vc && vc->vc_sw == &sisusb_con) {
1199 if (con_is_visible(vc)) {
1200 vc->vc_sw->con_cursor(vc, CM_DRAW);
1201 }
1202 vc->vc_font.height = fh;
1203 vc_resize(vc, 0, rows);
1204 }
1205 }
1206 }
1207
1208 return 0;
1209
1210font_op_error:
1211 if (uplock)
1212 mutex_unlock(&sisusb->lock);
1213
1214 return -EIO;
1215}
1216
1217/* Interface routine */
1218static int
1219sisusbcon_font_set(struct vc_data *c, struct console_font *font,
1220 unsigned int flags)
1221{
1222 struct sisusb_usb_data *sisusb;
1223 unsigned charcount = font->charcount;
1224
1225 if (font->width != 8 || (charcount != 256 && charcount != 512))
1226 return -EINVAL;
1227
1228 sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num);
1229 if (!sisusb)
1230 return -ENODEV;
1231
1232 /* sisusb->lock is down */
1233
1234 /* Save the user-provided font into a buffer. This
1235 * is used for restoring text mode after quitting
1236 * from X and for the con_getfont routine.
1237 */
1238 if (sisusb->font_backup) {
1239 if (sisusb->font_backup_size < charcount) {
1240 vfree(sisusb->font_backup);
1241 sisusb->font_backup = NULL;
1242 }
1243 }
1244
1245 if (!sisusb->font_backup)
1246 sisusb->font_backup = vmalloc(charcount * 32);
1247
1248 if (sisusb->font_backup) {
1249 memcpy(sisusb->font_backup, font->data, charcount * 32);
1250 sisusb->font_backup_size = charcount;
1251 sisusb->font_backup_height = font->height;
1252 sisusb->font_backup_512 = (charcount == 512) ? 1 : 0;
1253 }
1254
1255 /* do_font_op ups sisusb->lock */
1256
1257 return sisusbcon_do_font_op(sisusb, 1, 2, font->data,
1258 8192, (charcount == 512),
1259 (!(flags & KD_FONT_FLAG_DONT_RECALC)) ? 1 : 0,
1260 c, font->height, 1);
1261}
1262
1263/* Interface routine */
1264static int
1265sisusbcon_font_get(struct vc_data *c, struct console_font *font)
1266{
1267 struct sisusb_usb_data *sisusb;
1268
1269 sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num);
1270 if (!sisusb)
1271 return -ENODEV;
1272
1273 /* sisusb->lock is down */
1274
1275 font->width = 8;
1276 font->height = c->vc_font.height;
1277 font->charcount = 256;
1278
1279 if (!font->data) {
1280 mutex_unlock(&sisusb->lock);
1281 return 0;
1282 }
1283
1284 if (!sisusb->font_backup) {
1285 mutex_unlock(&sisusb->lock);
1286 return -ENODEV;
1287 }
1288
1289 /* Copy 256 chars only, like vgacon */
1290 memcpy(font->data, sisusb->font_backup, 256 * 32);
1291
1292 mutex_unlock(&sisusb->lock);
1293
1294 return 0;
1295}
1296
1297/*
1298 * The console `switch' structure for the sisusb console
1299 */
1300
1301static const struct consw sisusb_con = {
1302 .owner = THIS_MODULE,
1303 .con_startup = sisusbcon_startup,
1304 .con_init = sisusbcon_init,
1305 .con_deinit = sisusbcon_deinit,
1306 .con_clear = sisusbcon_clear,
1307 .con_putc = sisusbcon_putc,
1308 .con_putcs = sisusbcon_putcs,
1309 .con_cursor = sisusbcon_cursor,
1310 .con_scroll = sisusbcon_scroll,
1311 .con_switch = sisusbcon_switch,
1312 .con_blank = sisusbcon_blank,
1313 .con_font_set = sisusbcon_font_set,
1314 .con_font_get = sisusbcon_font_get,
1315 .con_set_palette = sisusbcon_set_palette,
1316 .con_scrolldelta = sisusbcon_scrolldelta,
1317 .con_build_attr = sisusbcon_build_attr,
1318 .con_invert_region = sisusbcon_invert_region,
1319 .con_set_origin = sisusbcon_set_origin,
1320 .con_save_screen = sisusbcon_save_screen,
1321 .con_resize = sisusbcon_resize,
1322};
1323
1324/* Our very own dummy console driver */
1325
1326static const char *sisusbdummycon_startup(void)
1327{
1328 return "SISUSBVGADUMMY";
1329}
1330
1331static void sisusbdummycon_init(struct vc_data *vc, int init)
1332{
1333 vc->vc_can_do_color = 1;
1334 if (init) {
1335 vc->vc_cols = 80;
1336 vc->vc_rows = 25;
1337 } else
1338 vc_resize(vc, 80, 25);
1339}
1340
1341static void sisusbdummycon_deinit(struct vc_data *vc) { }
1342static void sisusbdummycon_clear(struct vc_data *vc, int sy, int sx,
1343 int height, int width) { }
1344static void sisusbdummycon_putc(struct vc_data *vc, int c, int ypos,
1345 int xpos) { }
1346static void sisusbdummycon_putcs(struct vc_data *vc, const unsigned short *s,
1347 int count, int ypos, int xpos) { }
1348static void sisusbdummycon_cursor(struct vc_data *vc, int mode) { }
1349
1350static bool sisusbdummycon_scroll(struct vc_data *vc, unsigned int top,
1351 unsigned int bottom, enum con_scroll dir,
1352 unsigned int lines)
1353{
1354 return false;
1355}
1356
1357static int sisusbdummycon_switch(struct vc_data *vc)
1358{
1359 return 0;
1360}
1361
1362static int sisusbdummycon_blank(struct vc_data *vc, int blank, int mode_switch)
1363{
1364 return 0;
1365}
1366
1367static int sisusbdummycon_font_set(struct vc_data *vc,
1368 struct console_font *font,
1369 unsigned int flags)
1370{
1371 return 0;
1372}
1373
1374static int sisusbdummycon_font_default(struct vc_data *vc,
1375 struct console_font *font, char *name)
1376{
1377 return 0;
1378}
1379
1380static int sisusbdummycon_font_copy(struct vc_data *vc, int con)
1381{
1382 return 0;
1383}
1384
1385static const struct consw sisusb_dummy_con = {
1386 .owner = THIS_MODULE,
1387 .con_startup = sisusbdummycon_startup,
1388 .con_init = sisusbdummycon_init,
1389 .con_deinit = sisusbdummycon_deinit,
1390 .con_clear = sisusbdummycon_clear,
1391 .con_putc = sisusbdummycon_putc,
1392 .con_putcs = sisusbdummycon_putcs,
1393 .con_cursor = sisusbdummycon_cursor,
1394 .con_scroll = sisusbdummycon_scroll,
1395 .con_switch = sisusbdummycon_switch,
1396 .con_blank = sisusbdummycon_blank,
1397 .con_font_set = sisusbdummycon_font_set,
1398 .con_font_default = sisusbdummycon_font_default,
1399 .con_font_copy = sisusbdummycon_font_copy,
1400};
1401
1402int
1403sisusb_console_init(struct sisusb_usb_data *sisusb, int first, int last)
1404{
1405 int i, ret;
1406
1407 mutex_lock(&sisusb->lock);
1408
1409 /* Erm.. that should not happen */
1410 if (sisusb->haveconsole || !sisusb->SiS_Pr) {
1411 mutex_unlock(&sisusb->lock);
1412 return 1;
1413 }
1414
1415 sisusb->con_first = first;
1416 sisusb->con_last = last;
1417
1418 if (first > last ||
1419 first > MAX_NR_CONSOLES ||
1420 last > MAX_NR_CONSOLES) {
1421 mutex_unlock(&sisusb->lock);
1422 return 1;
1423 }
1424
1425 /* If gfxcore not initialized or no consoles given, quit graciously */
1426 if (!sisusb->gfxinit || first < 1 || last < 1) {
1427 mutex_unlock(&sisusb->lock);
1428 return 0;
1429 }
1430
1431 sisusb->sisusb_cursor_loc = -1;
1432 sisusb->sisusb_cursor_size_from = -1;
1433 sisusb->sisusb_cursor_size_to = -1;
1434
1435 /* Set up text mode (and upload default font) */
1436 if (sisusb_reset_text_mode(sisusb, 1)) {
1437 mutex_unlock(&sisusb->lock);
1438 dev_err(&sisusb->sisusb_dev->dev, "Failed to set up text mode\n");
1439 return 1;
1440 }
1441
1442 /* Initialize some gfx registers */
1443 sisusb_initialize(sisusb);
1444
1445 for (i = first - 1; i <= last - 1; i++) {
1446 /* Save sisusb for our interface routines */
1447 mysisusbs[i] = sisusb;
1448 }
1449
1450 /* Initial console setup */
1451 sisusb->sisusb_num_columns = 80;
1452
1453 /* Use a 32K buffer (matches b8000-bffff area) */
1454 sisusb->scrbuf_size = 32 * 1024;
1455
1456 /* Allocate screen buffer */
1457 if (!(sisusb->scrbuf = (unsigned long)vmalloc(sisusb->scrbuf_size))) {
1458 mutex_unlock(&sisusb->lock);
1459 dev_err(&sisusb->sisusb_dev->dev, "Failed to allocate screen buffer\n");
1460 return 1;
1461 }
1462
1463 mutex_unlock(&sisusb->lock);
1464
1465 /* Now grab the desired console(s) */
1466 console_lock();
1467 ret = do_take_over_console(&sisusb_con, first - 1, last - 1, 0);
1468 console_unlock();
1469 if (!ret)
1470 sisusb->haveconsole = 1;
1471 else {
1472 for (i = first - 1; i <= last - 1; i++)
1473 mysisusbs[i] = NULL;
1474 }
1475
1476 return ret;
1477}
1478
1479void
1480sisusb_console_exit(struct sisusb_usb_data *sisusb)
1481{
1482 int i;
1483
1484 /* This is called if the device is disconnected
1485 * and while disconnect and lock semaphores
1486 * are up. This should be save because we
1487 * can't lose our sisusb any other way but by
1488 * disconnection (and hence, the disconnect
1489 * sema is for protecting all other access
1490 * functions from disconnection, not the
1491 * other way round).
1492 */
1493
1494 /* Now what do we do in case of disconnection:
1495 * One alternative would be to simply call
1496 * give_up_console(). Nah, not a good idea.
1497 * give_up_console() is obviously buggy as it
1498 * only discards the consw pointer from the
1499 * driver_map, but doesn't adapt vc->vc_sw
1500 * of the affected consoles. Hence, the next
1501 * call to any of the console functions will
1502 * eventually take a trip to oops county.
1503 * Also, give_up_console for some reason
1504 * doesn't decrement our module refcount.
1505 * Instead, we switch our consoles to a private
1506 * dummy console. This, of course, keeps our
1507 * refcount up as well, but it works perfectly.
1508 */
1509
1510 if (sisusb->haveconsole) {
1511 for (i = 0; i < MAX_NR_CONSOLES; i++)
1512 if (sisusb->havethisconsole[i]) {
1513 console_lock();
1514 do_take_over_console(&sisusb_dummy_con, i, i, 0);
1515 console_unlock();
1516 /* At this point, con_deinit for all our
1517 * consoles is executed by do_take_over_console().
1518 */
1519 }
1520 sisusb->haveconsole = 0;
1521 }
1522
1523 vfree((void *)sisusb->scrbuf);
1524 sisusb->scrbuf = 0;
1525
1526 vfree(sisusb->font_backup);
1527 sisusb->font_backup = NULL;
1528}
1529
1530void __init sisusb_init_concode(void)
1531{
1532 int i;
1533
1534 for (i = 0; i < MAX_NR_CONSOLES; i++)
1535 mysisusbs[i] = NULL;
1536}
1537
1538#endif /* INCL_CON */
1539
1540
1541