git.oblomov.eu Git - linux-2.6/blob - drivers/usb/misc/sisusbvga/sisusb_con.c

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