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