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