xorg-server-1.4/hw/xfree86/os-support/bsd/bsd_init.c

   1 /*
   2  * Copyright 1992 by Rich Murphey <Rich@Rice.edu>
   3  * Copyright 1993 by David Wexelblat <dwex@goblin.org>
   4  *
   5  * Permission to use, copy, modify, distribute, and sell this software and its
   6  * documentation for any purpose is hereby granted without fee, provided that
   7  * the above copyright notice appear in all copies and that both that
   8  * copyright notice and this permission notice appear in supporting
   9  * documentation, and that the names of Rich Murphey and David Wexelblat
  10  * not be used in advertising or publicity pertaining to distribution of
  11  * the software without specific, written prior permission.  Rich Murphey and
  12  * David Wexelblat make no representations about the suitability of this
  13  * software for any purpose.  It is provided "as is" without express or
  14  * implied warranty.
  15  *
  16  * RICH MURPHEY AND DAVID WEXELBLAT DISCLAIM ALL WARRANTIES WITH REGARD TO
  17  * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  18  * FITNESS, IN NO EVENT SHALL RICH MURPHEY OR DAVID WEXELBLAT BE LIABLE FOR
  19  * ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
  20  * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
  21  * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  22  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  23  *
  24  */
  25
  26 #ifdef HAVE_XORG_CONFIG_H
  27 #include <xorg-config.h>
  28 #endif
  29
  30 #include <X11/X.h>
  31
  32 #include "compiler.h"
  33
  34 #include "xf86.h"
  35 #include "xf86Priv.h"
  36 #include "xf86_OSlib.h"
  37
  38 #include <sys/utsname.h>
  39 #include <sys/ioctl.h>
  40 #include <stdlib.h>
  41 #include <errno.h>
  42
  43 static Bool KeepTty = FALSE;
  44 static int devConsoleFd = -1;
  45 #if defined (SYSCONS_SUPPORT) || defined (PCVT_SUPPORT)
  46 static int VTnum = -1;
  47 static int initialVT = -1;
  48 #endif
  49
  50 #ifdef PCCONS_SUPPORT
  51 /* Stock 0.1 386bsd pccons console driver interface */
  52 #ifndef __OpenBSD__
  53 #  define PCCONS_CONSOLE_DEV1 "/dev/ttyv0"
  54 #else
  55 #  define PCCONS_CONSOLE_DEV1 "/dev/ttyC0"
  56 #endif
  57 #define PCCONS_CONSOLE_DEV2 "/dev/vga"
  58 #define PCCONS_CONSOLE_MODE O_RDWR|O_NDELAY
  59 #endif
  60
  61 #ifdef SYSCONS_SUPPORT
  62 /* The FreeBSD 1.1 version syscons driver uses /dev/ttyv0 */
  63 #define SYSCONS_CONSOLE_DEV1 "/dev/ttyv0"
  64 #define SYSCONS_CONSOLE_DEV2 "/dev/vga"
  65 #define SYSCONS_CONSOLE_MODE O_RDWR|O_NDELAY
  66 #endif
  67
  68 #ifdef PCVT_SUPPORT
  69 /* Hellmuth Michaelis' pcvt driver */
  70 #ifndef __OpenBSD__
  71 #  define PCVT_CONSOLE_DEV "/dev/ttyv0"
  72 #else
  73 #  define PCVT_CONSOLE_DEV "/dev/ttyC0"
  74 #endif
  75 #define PCVT_CONSOLE_MODE O_RDWR|O_NDELAY
  76 #endif
  77
  78 #if defined(WSCONS_SUPPORT) && defined(__NetBSD__)
  79 /* NetBSD's new console driver */
  80 #define WSCONS_PCVT_COMPAT_CONSOLE_DEV "/dev/ttyE0"
  81 #endif
  82
  83 #ifdef __GLIBC__
  84 #define setpgrp setpgid
  85 #endif
  86
  87 #define CHECK_DRIVER_MSG \
  88   "Check your kernel's console driver configuration and /dev entries"
  89
  90 static char *supported_drivers[] = {
  91 #ifdef PCCONS_SUPPORT
  92         "pccons (with X support)",
  93 #endif
  94 #ifdef SYSCONS_SUPPORT
  95         "syscons",
  96 #endif
  97 #ifdef PCVT_SUPPORT
  98         "pcvt",
  99 #endif
 100 #ifdef WSCONS_SUPPORT
 101         "wscons",
 102 #endif
 103 };
 104
 105
 106 /*
 107  * Functions to probe for the existance of a supported console driver.
 108  * Any function returns either a valid file descriptor (driver probed
 109  * succesfully), -1 (driver not found), or uses FatalError() if the
 110  * driver was found but proved to not support the required mode to run
 111  * an X server.
 112  */
 113
 114 typedef int (*xf86ConsOpen_t)(void);
 115
 116 #ifdef PCCONS_SUPPORT
 117 static int xf86OpenPccons(void);
 118 #endif /* PCCONS_SUPPORT */
 119
 120 #ifdef SYSCONS_SUPPORT
 121 static int xf86OpenSyscons(void);
 122 #endif /* SYSCONS_SUPPORT */
 123
 124 #ifdef PCVT_SUPPORT
 125 static int xf86OpenPcvt(void);
 126 #endif /* PCVT_SUPPORT */
 127
 128 #ifdef WSCONS_SUPPORT
 129 static int xf86OpenWScons(void);
 130 #endif
 131
 132 /*
 133  * The sequence of the driver probes is important; start with the
 134  * driver that is best distinguishable, and end with the most generic
 135  * driver.  (Otherwise, pcvt would also probe as syscons, and either
 136  * pcvt or syscons might succesfully probe as pccons.)
 137  */
 138 static xf86ConsOpen_t xf86ConsTab[] = {
 139 #ifdef PCVT_SUPPORT
 140     xf86OpenPcvt,
 141 #endif
 142 #ifdef SYSCONS_SUPPORT
 143     xf86OpenSyscons,
 144 #endif
 145 #ifdef PCCONS_SUPPORT
 146     xf86OpenPccons,
 147 #endif
 148 #ifdef WSCONS_SUPPORT
 149     xf86OpenWScons,
 150 #endif
 151     (xf86ConsOpen_t)NULL
 152 };
 153
 154
 155 void
 156 xf86OpenConsole()
 157 {
 158     int i, fd = -1;
 159     xf86ConsOpen_t *driver;
 160 #if defined (SYSCONS_SUPPORT) || defined (PCVT_SUPPORT)
 161     int result;
 162     struct utsname uts;
 163     vtmode_t vtmode;
 164 #endif
 165
 166     if (serverGeneration == 1)
 167     {
 168         /* check if we are run with euid==0 */
 169         if (geteuid() != 0)
 170         {
 171             FatalError("xf86OpenConsole: Server must be suid root");
 172         }
 173
 174         if (!KeepTty)
 175         {
 176             /*
 177              * detaching the controlling tty solves problems of kbd character
 178              * loss.  This is not interesting for CO driver, because it is
 179              * exclusive.
 180              */
 181             setpgrp(0, getpid());
 182             if ((i = open("/dev/tty",O_RDWR)) >= 0)
 183             {
 184                 ioctl(i,TIOCNOTTY,(char *)0);
 185                 close(i);
 186             }
 187         }
 188
 189         /* detect which driver we are running on */
 190         for (driver = xf86ConsTab; *driver; driver++)
 191         {
 192             if ((fd = (*driver)()) >= 0)
 193                 break;
 194         }
 195
 196         /* Check that a supported console driver was found */
 197         if (fd < 0)
 198         {
 199             char cons_drivers[80] = {0, };
 200             for (i = 0; i < sizeof(supported_drivers) / sizeof(char *); i++)
 201             {
 202                 if (i)
 203                 {
 204                     strcat(cons_drivers, ", ");
 205                 }
 206                 strcat(cons_drivers, supported_drivers[i]);
 207             }
 208             FatalError(
 209                 "%s: No console driver found\n\tSupported drivers: %s\n\t%s",
 210                 "xf86OpenConsole", cons_drivers, CHECK_DRIVER_MSG);
 211         }
 212 #if 0 /* stdin is already closed in OsInit() */
 213         fclose(stdin);
 214 #endif
 215         xf86Info.consoleFd = fd;
 216         xf86Info.screenFd = fd;
 217
 218         switch (xf86Info.consType)
 219         {
 220 #ifdef PCCONS_SUPPORT
 221         case PCCONS:
 222             if (ioctl (xf86Info.consoleFd, CONSOLE_X_MODE_ON, 0) < 0)
 223             {
 224                 FatalError("%s: CONSOLE_X_MODE_ON failed (%s)\n%s",
 225                            "xf86OpenConsole", strerror(errno),
 226                            CHECK_DRIVER_MSG);
 227             }
 228             /*
 229              * Hack to prevent keyboard hanging when syslogd closes
 230              * /dev/console
 231              */
 232             if ((devConsoleFd = open("/dev/console", O_WRONLY,0)) < 0)
 233             {
 234                 xf86Msg(X_WARNING,
 235                         "xf86OpenConsole: couldn't open /dev/console (%s)\n",
 236                         strerror(errno));
 237             }
 238             break;
 239 #endif
 240 #if defined (SYSCONS_SUPPORT) || defined (PCVT_SUPPORT)
 241         case SYSCONS:
 242             /* as of FreeBSD 2.2.8, syscons driver does not need the #1 vt
 243              * switching anymore. Here we check for FreeBSD 3.1 and up.
 244              * Add cases for other *BSD that behave the same.
 245             */
 246 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
 247             uname (&uts);
 248             i = atof(uts.release) * 100;
 249             if (i >= 310) goto acquire_vt;
 250 #endif
 251             /* otherwise fall through */
 252         case PCVT:
 253             /*
 254              * First activate the #1 VT.  This is a hack to allow a server
 255              * to be started while another one is active.  There should be
 256              * a better way.
 257              */
 258             if (initialVT != 1) {
 259
 260                 if (ioctl(xf86Info.consoleFd, VT_ACTIVATE, 1) != 0)
 261                 {
 262                     xf86Msg(X_WARNING,
 263                                 "xf86OpenConsole: VT_ACTIVATE failed\n");
 264                 }
 265                 sleep(1);
 266             }
 267
 268 acquire_vt:
 269             /*
 270              * now get the VT
 271              */
 272             SYSCALL(result =
 273                     ioctl(xf86Info.consoleFd, VT_ACTIVATE, xf86Info.vtno));
 274             if (result != 0)
 275             {
 276                 xf86Msg(X_WARNING, "xf86OpenConsole: VT_ACTIVATE failed\n");
 277             }
 278             SYSCALL(result =
 279                     ioctl(xf86Info.consoleFd, VT_WAITACTIVE, xf86Info.vtno));
 280             if (result != 0)
 281             {
 282                 xf86Msg(X_WARNING, "xf86OpenConsole: VT_WAITACTIVE failed\n");
 283             }
 284
 285             signal(SIGUSR1, xf86VTRequest);
 286
 287             vtmode.mode = VT_PROCESS;
 288             vtmode.relsig = SIGUSR1;
 289             vtmode.acqsig = SIGUSR1;
 290             vtmode.frsig = SIGUSR1;
 291             if (ioctl(xf86Info.consoleFd, VT_SETMODE, &vtmode) < 0)
 292             {
 293                 FatalError("xf86OpenConsole: VT_SETMODE VT_PROCESS failed");
 294             }
 295 #if !defined(USE_DEV_IO) && !defined(USE_I386_IOPL)
 296             if (ioctl(xf86Info.consoleFd, KDENABIO, 0) < 0)
 297             {
 298                 FatalError("xf86OpenConsole: KDENABIO failed (%s)",
 299                            strerror(errno));
 300             }
 301 #endif
 302             if (ioctl(xf86Info.consoleFd, KDSETMODE, KD_GRAPHICS) < 0)
 303             {
 304                 FatalError("xf86OpenConsole: KDSETMODE KD_GRAPHICS failed");
 305             }
 306             break;
 307 #endif /* SYSCONS_SUPPORT || PCVT_SUPPORT */
 308 #ifdef WSCONS_SUPPORT
 309         case WSCONS:
 310             fprintf(stderr, "xf86OpenConsole\n");
 311             /* xf86Info.consoleFd = open("/dev/wskbd0", 0); */
 312             break;
 313 #endif
 314         }
 315     }
 316     else
 317     {
 318         /* serverGeneration != 1 */
 319 #if defined (SYSCONS_SUPPORT) || defined (PCVT_SUPPORT)
 320         if (xf86Info.consType == SYSCONS || xf86Info.consType == PCVT)
 321         {
 322             if (ioctl(xf86Info.consoleFd, VT_ACTIVATE, xf86Info.vtno) != 0)
 323             {
 324                 xf86Msg(X_WARNING, "xf86OpenConsole: VT_ACTIVATE failed\n");
 325             }
 326         }
 327 #endif /* SYSCONS_SUPPORT || PCVT_SUPPORT */
 328     }
 329     return;
 330 }
 331
 332
 333 #ifdef PCCONS_SUPPORT
 334
 335 static int
 336 xf86OpenPccons()
 337 {
 338     int fd = -1;
 339
 340     if ((fd = open(PCCONS_CONSOLE_DEV1, PCCONS_CONSOLE_MODE, 0))
 341         >= 0 ||
 342         (fd = open(PCCONS_CONSOLE_DEV2, PCCONS_CONSOLE_MODE, 0))
 343         >= 0)
 344     {
 345         if (ioctl(fd, CONSOLE_X_MODE_OFF, 0) < 0)
 346         {
 347             FatalError(
 348                 "%s: CONSOLE_X_MODE_OFF failed (%s)\n%s\n%s",
 349                 "xf86OpenPccons",
 350                 strerror(errno),
 351                 "Was expecting pccons driver with X support",
 352                 CHECK_DRIVER_MSG);
 353         }
 354         xf86Info.consType = PCCONS;
 355         xf86Msg(X_PROBED, "Using pccons driver with X support\n");
 356     }
 357     return fd;
 358 }
 359
 360 #endif /* PCCONS_SUPPORT */
 361
 362 #ifdef SYSCONS_SUPPORT
 363
 364 static int
 365 xf86OpenSyscons()
 366 {
 367     int fd = -1;
 368     vtmode_t vtmode;
 369     char vtname[12];
 370     struct stat status;
 371     long syscons_version;
 372     MessageType from;
 373
 374     /* Check for syscons */
 375     if ((fd = open(SYSCONS_CONSOLE_DEV1, SYSCONS_CONSOLE_MODE, 0)) >= 0
 376         || (fd = open(SYSCONS_CONSOLE_DEV2, SYSCONS_CONSOLE_MODE, 0)) >= 0)
 377     {
 378         if (ioctl(fd, VT_GETMODE, &vtmode) >= 0)
 379         {
 380             /* Get syscons version */
 381             if (ioctl(fd, CONS_GETVERS, &syscons_version) < 0)
 382             {
 383                 syscons_version = 0;
 384             }
 385
 386             xf86Info.vtno = VTnum;
 387             from = X_CMDLINE;
 388
 389 #ifdef VT_GETACTIVE
 390             if (ioctl(fd, VT_GETACTIVE, &initialVT) < 0)
 391                 initialVT = -1;
 392 #endif
 393             if (xf86Info.vtno == -1)
 394             {
 395                 /*
 396                  * For old syscons versions (<0x100), VT_OPENQRY returns
 397                  * the current VT rather than the next free VT.  In this
 398                  * case, the server gets started on the current VT instead
 399                  * of the next free VT.
 400                  */
 401
 402 #if 0
 403                 /* check for the fixed VT_OPENQRY */
 404                 if (syscons_version >= 0x100)
 405                 {
 406 #endif
 407                     if (ioctl(fd, VT_OPENQRY, &xf86Info.vtno) < 0)
 408                     {
 409                         /* No free VTs */
 410                         xf86Info.vtno = -1;
 411                     }
 412 #if 0
 413                 }
 414 #endif
 415
 416                 if (xf86Info.vtno == -1)
 417                 {
 418                     /*
 419                      * All VTs are in use.  If initialVT was found, use it.
 420                      * Otherwise, if stdin is a VT, use that one.
 421                      * XXX stdin is already closed, so this won't work.
 422                      */
 423                     if (initialVT != -1)
 424                     {
 425                         xf86Info.vtno = initialVT;
 426                     }
 427                     else if ((fstat(0, &status) >= 0)
 428                              && S_ISCHR(status.st_mode)
 429                              && (ioctl(0, VT_GETMODE, &vtmode) >= 0))
 430                     {
 431                         /* stdin is a VT */
 432                         xf86Info.vtno = minor(status.st_rdev) + 1;
 433                     }
 434                     else
 435                     {
 436                         if (syscons_version >= 0x100)
 437                         {
 438                             FatalError("%s: Cannot find a free VT",
 439                                        "xf86OpenSyscons");
 440                         }
 441                         /* Should no longer reach here */
 442                         FatalError("%s: %s %s\n\t%s %s",
 443                                    "xf86OpenSyscons",
 444                                    "syscons versions prior to 1.0 require",
 445                                    "either the",
 446                                    "server's stdin be a VT",
 447                                    "or the use of the vtxx server option");
 448                     }
 449                 }
 450                 from = X_PROBED;
 451             }
 452
 453             close(fd);
 454 #ifndef __OpenBSD__
 455             sprintf(vtname, "/dev/ttyv%01x", xf86Info.vtno - 1);
 456 #else
 457             sprintf(vtname, "/dev/ttyC%01x", xf86Info.vtno - 1);
 458 #endif
 459             if ((fd = open(vtname, SYSCONS_CONSOLE_MODE, 0)) < 0)
 460             {
 461                 FatalError("xf86OpenSyscons: Cannot open %s (%s)",
 462                            vtname, strerror(errno));
 463             }
 464             if (ioctl(fd, VT_GETMODE, &vtmode) < 0)
 465             {
 466                 FatalError("xf86OpenSyscons: VT_GETMODE failed");
 467             }
 468             xf86Info.consType = SYSCONS;
 469             xf86Msg(X_PROBED, "Using syscons driver with X support");
 470             if (syscons_version >= 0x100)
 471             {
 472                 xf86ErrorF(" (version %ld.%ld)\n", syscons_version >> 8,
 473                            syscons_version & 0xFF);
 474             }
 475             else
 476             {
 477                 xf86ErrorF(" (version 0.x)\n");
 478             }
 479             xf86Msg(from, "using VT number %d\n\n", xf86Info.vtno);
 480         }
 481         else
 482         {
 483             /* VT_GETMODE failed, probably not syscons */
 484             close(fd);
 485             fd = -1;
 486         }
 487     }
 488     return fd;
 489 }
 490
 491 #endif /* SYSCONS_SUPPORT */
 492
 493
 494 #ifdef PCVT_SUPPORT
 495
 496 static int
 497 xf86OpenPcvt()
 498 {
 499     /* This looks much like syscons, since pcvt is API compatible */
 500     int fd = -1;
 501     vtmode_t vtmode;
 502     char vtname[12], *vtprefix;
 503     struct stat status;
 504     struct pcvtid pcvt_version;
 505
 506 #ifndef __OpenBSD__
 507     vtprefix = "/dev/ttyv";
 508 #else
 509     vtprefix = "/dev/ttyC";
 510 #endif
 511
 512     fd = open(PCVT_CONSOLE_DEV, PCVT_CONSOLE_MODE, 0);
 513 #ifdef WSCONS_PCVT_COMPAT_CONSOLE_DEV
 514     if (fd < 0)
 515     {
 516         fd = open(WSCONS_PCVT_COMPAT_CONSOLE_DEV, PCVT_CONSOLE_MODE, 0);
 517         vtprefix = "/dev/ttyE";
 518     }
 519 #endif
 520     if (fd >= 0)
 521     {
 522         if (ioctl(fd, VGAPCVTID, &pcvt_version) >= 0)
 523         {
 524             if(ioctl(fd, VT_GETMODE, &vtmode) < 0)
 525             {
 526                 FatalError("%s: VT_GETMODE failed\n%s%s\n%s",
 527                            "xf86OpenPcvt",
 528                            "Found pcvt driver but X11 seems to be",
 529                            " not supported.", CHECK_DRIVER_MSG);
 530             }
 531
 532             xf86Info.vtno = VTnum;
 533
 534             if (ioctl(fd, VT_GETACTIVE, &initialVT) < 0)
 535                 initialVT = -1;
 536
 537             if (xf86Info.vtno == -1)
 538             {
 539                 if (ioctl(fd, VT_OPENQRY, &xf86Info.vtno) < 0)
 540                 {
 541                     /* No free VTs */
 542                     xf86Info.vtno = -1;
 543                 }
 544
 545                 if (xf86Info.vtno == -1)
 546                 {
 547                     /*
 548                      * All VTs are in use.  If initialVT was found, use it.
 549                      * Otherwise, if stdin is a VT, use that one.
 550                      * XXX stdin is already closed, so this won't work.
 551                      */
 552                     if (initialVT != -1)
 553                     {
 554                         xf86Info.vtno = initialVT;
 555                     }
 556                     else if ((fstat(0, &status) >= 0)
 557                              && S_ISCHR(status.st_mode)
 558                              && (ioctl(0, VT_GETMODE, &vtmode) >= 0))
 559                     {
 560                         /* stdin is a VT */
 561                         xf86Info.vtno = minor(status.st_rdev) + 1;
 562                     }
 563                     else
 564                     {
 565                         FatalError("%s: Cannot find a free VT",
 566                                    "xf86OpenPcvt");
 567                     }
 568                 }
 569             }
 570
 571             close(fd);
 572             sprintf(vtname, "%s%01x", vtprefix, xf86Info.vtno - 1);
 573             if ((fd = open(vtname, PCVT_CONSOLE_MODE, 0)) < 0)
 574             {
 575                 FatalError("xf86OpenPcvt: Cannot open %s (%s)",
 576                            vtname, strerror(errno));
 577             }
 578             if (ioctl(fd, VT_GETMODE, &vtmode) < 0)
 579             {
 580                 FatalError("xf86OpenPcvt: VT_GETMODE failed");
 581             }
 582             xf86Info.consType = PCVT;
 583 #ifdef WSCONS_SUPPORT
 584             xf86Msg(X_PROBED,
 585                     "Using wscons driver in pcvt compatibility mode "
 586                     "(version %d.%d)\n",
 587                     pcvt_version.rmajor, pcvt_version.rminor);
 588 #else
 589             xf86Msg(X_PROBED, "Using pcvt driver (version %d.%d)\n",
 590                     pcvt_version.rmajor, pcvt_version.rminor);
 591 #endif
 592         }
 593         else
 594         {
 595             /* Not pcvt */
 596             close(fd);
 597             fd = -1;
 598         }
 599     }
 600     return fd;
 601 }
 602
 603 #endif /* PCVT_SUPPORT */
 604
 605 #ifdef WSCONS_SUPPORT
 606
 607 static int
 608 xf86OpenWScons()
 609 {
 610     int fd = -1;
 611     int mode = WSDISPLAYIO_MODE_MAPPED;
 612     int i;
 613     char ttyname[16];
 614
 615     /* XXX Is this ok? */
 616     for (i = 0; i < 8; i++) {
 617 #if defined(__NetBSD__)
 618         sprintf(ttyname, "/dev/ttyE%d", i);
 619 #elif defined(__OpenBSD__)
 620         sprintf(ttyname, "/dev/ttyC%d", i);
 621 #endif
 622         if ((fd = open(ttyname, 2)) != -1)
 623             break;
 624     }
 625     if (fd != -1) {
 626         if (ioctl(fd, WSDISPLAYIO_SMODE, &mode) < 0) {
 627             FatalError("%s: WSDISPLAYIO_MODE_MAPPED failed (%s)\n%s",
 628                        "xf86OpenConsole", strerror(errno),
 629                        CHECK_DRIVER_MSG);
 630         }
 631         xf86Info.consType = WSCONS;
 632         xf86Msg(X_PROBED, "Using wscons driver\n");
 633     }
 634     return fd;
 635 }
 636
 637 #endif /* WSCONS_SUPPORT */
 638
 639 void
 640 xf86CloseConsole()
 641 {
 642 #if defined(SYSCONS_SUPPORT) || defined(PCVT_SUPPORT)
 643     struct vt_mode   VT;
 644 #endif
 645
 646     switch (xf86Info.consType)
 647     {
 648 #ifdef PCCONS_SUPPORT
 649     case PCCONS:
 650         ioctl (xf86Info.consoleFd, CONSOLE_X_MODE_OFF, 0);
 651         break;
 652 #endif /* PCCONS_SUPPORT */
 653 #if defined (SYSCONS_SUPPORT) || defined (PCVT_SUPPORT)
 654     case SYSCONS:
 655     case PCVT:
 656         ioctl(xf86Info.consoleFd, KDSETMODE, KD_TEXT);  /* Back to text mode */
 657         if (ioctl(xf86Info.consoleFd, VT_GETMODE, &VT) != -1)
 658         {
 659             VT.mode = VT_AUTO;
 660             ioctl(xf86Info.consoleFd, VT_SETMODE, &VT); /* dflt vt handling */
 661         }
 662 #if !defined(USE_DEV_IO) && !defined(USE_I386_IOPL)
 663         if (ioctl(xf86Info.consoleFd, KDDISABIO, 0) < 0)
 664         {
 665             xf86FatalError("xf86CloseConsole: KDDISABIO failed (%s)",
 666                            strerror(errno));
 667         }
 668 #endif
 669         if (initialVT != -1)
 670                 ioctl(xf86Info.consoleFd, VT_ACTIVATE, initialVT);
 671         break;
 672 #endif /* SYSCONS_SUPPORT || PCVT_SUPPORT */
 673 #ifdef WSCONS_SUPPORT
 674     case WSCONS:
 675       {
 676         int mode = WSDISPLAYIO_MODE_EMUL;
 677         ioctl(xf86Info.screenFd, WSDISPLAYIO_SMODE, &mode);
 678         break;
 679       }
 680 #endif
 681     }
 682
 683     if (xf86Info.screenFd != xf86Info.consoleFd)
 684     {
 685         close(xf86Info.screenFd);
 686         close(xf86Info.consoleFd);
 687         if ((xf86Info.consoleFd = open("/dev/console",O_RDONLY,0)) <0)
 688         {
 689             xf86FatalError("xf86CloseConsole: Cannot open /dev/console (%s)",
 690                            strerror(errno));
 691         }
 692     }
 693     close(xf86Info.consoleFd);
 694     if (devConsoleFd >= 0)
 695         close(devConsoleFd);
 696     return;
 697 }
 698
 699 int
 700 xf86ProcessArgument(int argc, char *argv[], int i)
 701 {
 702         /*
 703          * Keep server from detaching from controlling tty.  This is useful
 704          * when debugging (so the server can receive keyboard signals.
 705          */
 706         if (!strcmp(argv[i], "-keeptty"))
 707         {
 708                 KeepTty = TRUE;
 709                 return(1);
 710         }
 711 #if defined (SYSCONS_SUPPORT) || defined (PCVT_SUPPORT)
 712         if ((argv[i][0] == 'v') && (argv[i][1] == 't'))
 713         {
 714                 if (sscanf(argv[i], "vt%2d", &VTnum) == 0 ||
 715                     VTnum < 1 || VTnum > 12)
 716                 {
 717                         UseMsg();
 718                         VTnum = -1;
 719                         return(0);
 720                 }
 721                 return(1);
 722         }
 723 #endif /* SYSCONS_SUPPORT || PCVT_SUPPORT */
 724         return(0);
 725 }
 726
 727 void
 728 xf86UseMsg()
 729 {
 730 #if defined (SYSCONS_SUPPORT) || defined (PCVT_SUPPORT)
 731         ErrorF("vtXX                   use the specified VT number (1-12)\n");
 732 #endif /* SYSCONS_SUPPORT || PCVT_SUPPORT */
 733         ErrorF("-keeptty               ");
 734         ErrorF("don't detach controlling tty (for debugging only)\n");
 735         return;
 736 }