Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 2e8ecb9db0bcc19e1cc8bb51e9252fe6a86a9863

Authored by Bill Nottingham 2007-10-17 14:29:38 +0800

Committed by Linus Torvalds 2007-10-17 23:42:56 +0800

Exists in master and in 7 other branches

add CONFIG_VT_UNICODE

As of now, the kernel defaults to non-unicode and XLATE for the keyboard.
We've been changing this in Fedora, but that requires patching the defaults
in the kernel.

The attached introduces CONFIG_VT_UNICODE, which sets the console in
unicode mode by default on boot, including both the virtual terminal and
the keyboard driver.

Signed-off-by: Bill Nottingham <notting@redhat.com>
Cc: Samuel Thibault <samuel.thibault@ens-lyon.org>
Cc: Dmitry Torokhov <dtor@mail.ru>
Cc: Jiri Kosina <jkosina@suse.cz>
Cc: Alan Cox <alan@lxorguk.ukuu.org.uk>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

Showing 6 changed files with 27 additions and 5 deletions Inline Diff

drivers/char/Kconfig
drivers/char/keyboard.c
drivers/char/sysrq.c
drivers/char/vt.c
drivers/char/vt_ioctl.c
include/linux/vt_kern.h

drivers/char/Kconfig

Diff comments View file @ 2e8ecb9

 #
 # Character device configuration
 #
 menu "Character devices"
 config VT
 	bool "Virtual terminal" if EMBEDDED
 	depends on !S390
 	select INPUT
 	default y if !VIOCONS
 	---help---
 	  If you say Y here, you will get support for terminal devices with
 	  display and keyboard devices. These are called "virtual" because you
 	  can run several virtual terminals (also called virtual consoles) on
 	  one physical terminal. This is rather useful, for example one
 	  virtual terminal can collect system messages and warnings, another
 	  one can be used for a text-mode user session, and a third could run
 	  an X session, all in parallel. Switching between virtual terminals
 	  is done with certain key combinations, usually Alt-<function key>.
 	  The setterm command ("man setterm") can be used to change the
 	  properties (such as colors or beeping) of a virtual terminal. The
 	  man page console_codes(4) ("man console_codes") contains the special
 	  character sequences that can be used to change those properties
 	  directly. The fonts used on virtual terminals can be changed with
 	  the setfont ("man setfont") command and the key bindings are defined
 	  with the loadkeys ("man loadkeys") command.
 	  You need at least one virtual terminal device in order to make use
 	  of your keyboard and monitor. Therefore, only people configuring an
 	  embedded system would want to say N here in order to save some
 	  memory; the only way to log into such a system is then via a serial
 	  or network connection.
 	  If unsure, say Y, or else you won't be able to do much with your new
 	  shiny Linux system :-)
+config VT_UNICODE
+	bool "Virtual console is Unicode by default"
+	depends on VT
+	default n
+	---help---
+	  If you say Y here, the virtual terminal will be in UTF-8 by default,
+	  and the keyboard will run in unicode mode.
+	  If you say N here, the virtual terminal will not be in UTF-8 by
+	  default, and the keyboard will run in XLATE mode.
+	  This can also be changed by passing 'default_utf8=<0|1>' on the
+	  kernel command line.
+	  Historically, the kernel has defaulted to non-UTF8 and XLATE mode.
+	  If unsure, say N here.
 config VT_CONSOLE
 	bool "Support for console on virtual terminal" if EMBEDDED
 	depends on VT
 	default y
 	---help---
 	  The system console is the device which receives all kernel messages
 	  and warnings and which allows logins in single user mode. If you
 	  answer Y here, a virtual terminal (the device used to interact with
 	  a physical terminal) can be used as system console. This is the most
 	  common mode of operations, so you should say Y here unless you want
 	  the kernel messages be output only to a serial port (in which case
 	  you should say Y to "Console on serial port", below).
 	  If you do say Y here, by default the currently visible virtual
 	  terminal (/dev/tty0) will be used as system console. You can change
 	  that with a kernel command line option such as "console=tty3" which
 	  would use the third virtual terminal as system console. (Try "man
 	  bootparam" or see the documentation of your boot loader (lilo or
 	  loadlin) about how to pass options to the kernel at boot time.)
 	  If unsure, say Y.
 config HW_CONSOLE
 	bool
 	depends on VT && !S390 && !UML
 	default y
 config VT_HW_CONSOLE_BINDING
        bool "Support for binding and unbinding console drivers"
        depends on HW_CONSOLE
        default n
        ---help---
          The virtual terminal is the device that interacts with the physical
          terminal through console drivers. On these systems, at least one
          console driver is loaded. In other configurations, additional console
          drivers may be enabled, such as the framebuffer console. If more than
          1 console driver is enabled, setting this to 'y' will allow you to
          select the console driver that will serve as the backend for the
          virtual terminals.
 	 See <file:Documentation/console/console.txt> for more
 	 information. For framebuffer console users, please refer to
 	 <file:Documentation/fb/fbcon.txt>.
 config SERIAL_NONSTANDARD
 	bool "Non-standard serial port support"
 	depends on HAS_IOMEM
 	---help---
 	  Say Y here if you have any non-standard serial boards -- boards
 	  which aren't supported using the standard "dumb" serial driver.
 	  This includes intelligent serial boards such as Cyclades,
 	  Digiboards, etc. These are usually used for systems that need many
 	  serial ports because they serve many terminals or dial-in
 	  connections.
 	  Note that the answer to this question won't directly affect the
 	  kernel: saying N will just cause the configurator to skip all
 	  the questions about non-standard serial boards.
 	  Most people can say N here.
 config COMPUTONE
 	tristate "Computone IntelliPort Plus serial support"
 	depends on SERIAL_NONSTANDARD && (ISA || EISA || PCI)
 	---help---
 	  This driver supports the entire family of Intelliport II/Plus
 	  controllers with the exception of the MicroChannel controllers and
 	  products previous to the Intelliport II. These are multiport cards,
 	  which give you many serial ports. You would need something like this
 	  to connect more than two modems to your Linux box, for instance in
 	  order to become a dial-in server. If you have a card like that, say
 	  Y here and read <file:Documentation/computone.txt>.
 	  To compile this driver as modules, choose M here: the
 	  modules will be called ip2 and ip2main.
 config ROCKETPORT
 	tristate "Comtrol RocketPort support"
 	depends on SERIAL_NONSTANDARD && (ISA || EISA || PCI)
 	help
 	  This driver supports Comtrol RocketPort and RocketModem PCI boards.
           These boards provide 2, 4, 8, 16, or 32 high-speed serial ports or
           modems.  For information about the RocketPort/RocketModem  boards
           and this driver read <file:Documentation/rocket.txt>.
 	  To compile this driver as a module, choose M here: the
 	  module will be called rocket.
 	  If you want to compile this driver into the kernel, say Y here.  If
           you don't have a Comtrol RocketPort/RocketModem card installed, say N.
 config CYCLADES
 	tristate "Cyclades async mux support"
 	depends on SERIAL_NONSTANDARD && (PCI || ISA)
 	select FW_LOADER
 	---help---
 	  This driver supports Cyclades Z and Y multiserial boards.
 	  You would need something like this to connect more than two modems to
 	  your Linux box, for instance in order to become a dial-in server.
 	  For information about the Cyclades-Z card, read
 	  <file:drivers/char/README.cycladesZ>.
 	  To compile this driver as a module, choose M here: the
 	  module will be called cyclades.
 	  If you haven't heard about it, it's safe to say N.
 config CYZ_INTR
 	bool "Cyclades-Z interrupt mode operation (EXPERIMENTAL)"
 	depends on EXPERIMENTAL && CYCLADES
 	help
 	  The Cyclades-Z family of multiport cards allows 2 (two) driver op
 	  modes: polling and interrupt. In polling mode, the driver will check
 	  the status of the Cyclades-Z ports every certain amount of time
 	  (which is called polling cycle and is configurable). In interrupt
 	  mode, it will use an interrupt line (IRQ) in order to check the
 	  status of the Cyclades-Z ports. The default op mode is polling. If
 	  unsure, say N.
 config DIGIEPCA
 	tristate "Digiboard Intelligent Async Support"
 	depends on SERIAL_NONSTANDARD && (ISA || EISA || PCI)
 	---help---
 	  This is a driver for Digi International's Xx, Xeve, and Xem series
 	  of cards which provide multiple serial ports. You would need
 	  something like this to connect more than two modems to your Linux
 	  box, for instance in order to become a dial-in server. This driver
 	  supports the original PC (ISA) boards as well as PCI, and EISA. If
 	  you have a card like this, say Y here and read the file
 	  <file:Documentation/digiepca.txt>.
 	  To compile this driver as a module, choose M here: the
 	  module will be called epca.
 config ESPSERIAL
 	tristate "Hayes ESP serial port support"
 	depends on SERIAL_NONSTANDARD && ISA && ISA_DMA_API
 	help
 	  This is a driver which supports Hayes ESP serial ports.  Both single
 	  port cards and multiport cards are supported.  Make sure to read
 	  <file:Documentation/hayes-esp.txt>.
 	  To compile this driver as a module, choose M here: the
 	  module will be called esp.
 	  If unsure, say N.
 config MOXA_INTELLIO
 	tristate "Moxa Intellio support"
 	depends on SERIAL_NONSTANDARD && (ISA || EISA || PCI)
 	help
 	  Say Y here if you have a Moxa Intellio multiport serial card.
 	  To compile this driver as a module, choose M here: the
 	  module will be called moxa.
 config MOXA_SMARTIO
 	tristate "Moxa SmartIO support (OBSOLETE)"
 	depends on SERIAL_NONSTANDARD
 	help
 	  Say Y here if you have a Moxa SmartIO multiport serial card.
 	  This driver can also be built as a module ( = code which can be
 	  inserted in and removed from the running kernel whenever you want).
 	  The module will be called mxser. If you want to do that, say M
 	  here.
 config MOXA_SMARTIO_NEW
 	tristate "Moxa SmartIO support v. 2.0"
 	depends on SERIAL_NONSTANDARD && (PCI || EISA || ISA)
 	help
 	  Say Y here if you have a Moxa SmartIO multiport serial card and/or
 	  want to help develop a new version of this driver.
 	  This is upgraded (1.9.1) driver from original Moxa drivers with
 	  changes finally resulting in PCI probing.
 	  This driver can also be built as a module. The module will be called
 	  mxser_new. If you want to do that, say M here.
 config ISI
 	tristate "Multi-Tech multiport card support (EXPERIMENTAL)"
 	depends on SERIAL_NONSTANDARD && PCI
 	select FW_LOADER
 	help
 	  This is a driver for the Multi-Tech cards which provide several
 	  serial ports.  The driver is experimental and can currently only be
 	  built as a module. The module will be called isicom.
 	  If you want to do that, choose M here.
 config SYNCLINK
 	tristate "Microgate SyncLink card support"
 	depends on SERIAL_NONSTANDARD && PCI && ISA_DMA_API
 	help
 	  Provides support for the SyncLink ISA and PCI multiprotocol serial
 	  adapters. These adapters support asynchronous and HDLC bit
 	  synchronous communication up to 10Mbps (PCI adapter).
 	  This driver can only be built as a module ( = code which can be
 	  inserted in and removed from the running kernel whenever you want).
 	  The module will be called synclink.  If you want to do that, say M
 	  here.
 config SYNCLINKMP
 	tristate "SyncLink Multiport support"
 	depends on SERIAL_NONSTANDARD && PCI
 	help
 	  Enable support for the SyncLink Multiport (2 or 4 ports)
 	  serial adapter, running asynchronous and HDLC communications up
 	  to 2.048Mbps. Each ports is independently selectable for
 	  RS-232, V.35, RS-449, RS-530, and X.21
 	  This driver may be built as a module ( = code which can be
 	  inserted in and removed from the running kernel whenever you want).
 	  The module will be called synclinkmp.  If you want to do that, say M
 	  here.
 config SYNCLINK_GT
 	tristate "SyncLink GT/AC support"
 	depends on SERIAL_NONSTANDARD && PCI
 	help
 	  Support for SyncLink GT and SyncLink AC families of
 	  synchronous and asynchronous serial adapters
 	  manufactured by Microgate Systems, Ltd. (www.microgate.com)
 config N_HDLC
 	tristate "HDLC line discipline support"
 	depends on SERIAL_NONSTANDARD
 	help
 	  Allows synchronous HDLC communications with tty device drivers that
 	  support synchronous HDLC such as the Microgate SyncLink adapter.
 	  This driver can only be built as a module ( = code which can be
 	  inserted in and removed from the running kernel whenever you want).
 	  The module will be called n_hdlc. If you want to do that, say M
 	  here.
 config RISCOM8
 	tristate "SDL RISCom/8 card support"
 	depends on SERIAL_NONSTANDARD && BROKEN_ON_SMP
 	help
 	  This is a driver for the SDL Communications RISCom/8 multiport card,
 	  which gives you many serial ports. You would need something like
 	  this to connect more than two modems to your Linux box, for instance
 	  in order to become a dial-in server. If you have a card like that,
 	  say Y here and read the file <file:Documentation/riscom8.txt>.
 	  Also it's possible to say M here and compile this driver as kernel
 	  loadable module; the module will be called riscom8.
 config SPECIALIX
 	tristate "Specialix IO8+ card support"
 	depends on SERIAL_NONSTANDARD
 	help
 	  This is a driver for the Specialix IO8+ multiport card (both the
 	  ISA and the PCI version) which gives you many serial ports. You
 	  would need something like this to connect more than two modems to
 	  your Linux box, for instance in order to become a dial-in server.
 	  If you have a card like that, say Y here and read the file
 	  <file:Documentation/specialix.txt>. Also it's possible to say M here
 	  and compile this driver as kernel loadable module which will be
 	  called specialix.
 config SPECIALIX_RTSCTS
 	bool "Specialix DTR/RTS pin is RTS"
 	depends on SPECIALIX
 	help
 	  The Specialix IO8+ card can only support either RTS or DTR. If you
 	  say N here, the driver will use the pin as "DTR" when the tty is in
 	  software handshake mode.  If you say Y here or hardware handshake is
 	  on, it will always be RTS.  Read the file
 	  <file:Documentation/specialix.txt> for more information.
 config SX
 	tristate "Specialix SX (and SI) card support"
 	depends on SERIAL_NONSTANDARD && (PCI || EISA || ISA)
 	help
 	  This is a driver for the SX and SI multiport serial cards.
 	  Please read the file <file:Documentation/sx.txt> for details.
 	  This driver can only be built as a module ( = code which can be
 	  inserted in and removed from the running kernel whenever you want).
 	  The module will be called sx. If you want to do that, say M here.
 config RIO
 	tristate "Specialix RIO system support"
 	depends on SERIAL_NONSTANDARD
 	help
 	  This is a driver for the Specialix RIO, a smart serial card which
 	  drives an outboard box that can support up to 128 ports.  Product
 	  information is at <http://www.perle.com/support/documentation.html#multiport>.
 	  There are both ISA and PCI versions.
 config RIO_OLDPCI
 	bool "Support really old RIO/PCI cards"
 	depends on RIO
 	help
 	  Older RIO PCI cards need some initialization-time configuration to
 	  determine the IRQ and some control addresses.  If you have a RIO and
 	  this doesn't seem to work, try setting this to Y.
 config STALDRV
 	bool "Stallion multiport serial support"
 	depends on SERIAL_NONSTANDARD
 	help
 	  Stallion cards give you many serial ports.  You would need something
 	  like this to connect more than two modems to your Linux box, for
 	  instance in order to become a dial-in server.  If you say Y here,
 	  you will be asked for your specific card model in the next
 	  questions.  Make sure to read <file:Documentation/stallion.txt> in
 	  this case.  If you have never heard about all this, it's safe to
 	  say N.
 config STALLION
 	tristate "Stallion EasyIO or EC8/32 support"
 	depends on STALDRV && BROKEN_ON_SMP && (ISA || EISA || PCI)
 	help
 	  If you have an EasyIO or EasyConnection 8/32 multiport Stallion
 	  card, then this is for you; say Y.  Make sure to read
 	  <file:Documentation/stallion.txt>.
 	  To compile this driver as a module, choose M here: the
 	  module will be called stallion.
 config ISTALLION
 	tristate "Stallion EC8/64, ONboard, Brumby support"
 	depends on STALDRV && BROKEN_ON_SMP && (ISA || EISA || PCI)
 	help
 	  If you have an EasyConnection 8/64, ONboard, Brumby or Stallion
 	  serial multiport card, say Y here. Make sure to read
 	  <file:Documentation/stallion.txt>.
 	  To compile this driver as a module, choose M here: the
 	  module will be called istallion.
 config A2232
 	tristate "Commodore A2232 serial support (EXPERIMENTAL)"
 	depends on EXPERIMENTAL && ZORRO && BROKEN_ON_SMP
 	---help---
 	  This option supports the 2232 7-port serial card shipped with the
 	  Amiga 2000 and other Zorro-bus machines, dating from 1989.  At
 	  a max of 19,200 bps, the ports are served by a 6551 ACIA UART chip
 	  each, plus a 8520 CIA, and a master 6502 CPU and buffer as well. The
 	  ports were connected with 8 pin DIN connectors on the card bracket,
 	  for which 8 pin to DB25 adapters were supplied. The card also had
 	  jumpers internally to toggle various pinning configurations.
 	  This driver can be built as a module; but then "generic_serial"
 	  will also be built as a module. This has to be loaded before
 	  "ser_a2232". If you want to do this, answer M here.
 config SGI_SNSC
 	bool "SGI Altix system controller communication support"
 	depends on (IA64_SGI_SN2 || IA64_GENERIC)
 	help
 	  If you have an SGI Altix and you want to enable system
 	  controller communication from user space (you want this!),
 	  say Y.  Otherwise, say N.
 config SGI_TIOCX
        bool "SGI TIO CX driver support"
        depends on (IA64_SGI_SN2 || IA64_GENERIC)
        help
          If you have an SGI Altix and you have fpga devices attached
          to your TIO, say Y here, otherwise say N.
 config SGI_MBCS
        tristate "SGI FPGA Core Services driver support"
        depends on SGI_TIOCX
        help
          If you have an SGI Altix with an attached SABrick
          say Y or M here, otherwise say N.
 source "drivers/serial/Kconfig"
 config UNIX98_PTYS
 	bool "Unix98 PTY support" if EMBEDDED
 	default y
 	---help---
 	  A pseudo terminal (PTY) is a software device consisting of two
 	  halves: a master and a slave. The slave device behaves identical to
 	  a physical terminal; the master device is used by a process to
 	  read data from and write data to the slave, thereby emulating a
 	  terminal. Typical programs for the master side are telnet servers
 	  and xterms.
 	  Linux has traditionally used the BSD-like names /dev/ptyxx for
 	  masters and /dev/ttyxx for slaves of pseudo terminals. This scheme
 	  has a number of problems. The GNU C library glibc 2.1 and later,
 	  however, supports the Unix98 naming standard: in order to acquire a
 	  pseudo terminal, a process opens /dev/ptmx; the number of the pseudo
 	  terminal is then made available to the process and the pseudo
 	  terminal slave can be accessed as /dev/pts/<number>. What was
 	  traditionally /dev/ttyp2 will then be /dev/pts/2, for example.
 	  All modern Linux systems use the Unix98 ptys.  Say Y unless
 	  you're on an embedded system and want to conserve memory.
 config LEGACY_PTYS
 	bool "Legacy (BSD) PTY support"
 	default y
 	---help---
 	  A pseudo terminal (PTY) is a software device consisting of two
 	  halves: a master and a slave. The slave device behaves identical to
 	  a physical terminal; the master device is used by a process to
 	  read data from and write data to the slave, thereby emulating a
 	  terminal. Typical programs for the master side are telnet servers
 	  and xterms.
 	  Linux has traditionally used the BSD-like names /dev/ptyxx
 	  for masters and /dev/ttyxx for slaves of pseudo
 	  terminals. This scheme has a number of problems, including
 	  security.  This option enables these legacy devices; on most
 	  systems, it is safe to say N.
 config LEGACY_PTY_COUNT
 	int "Maximum number of legacy PTY in use"
 	depends on LEGACY_PTYS
 	range 1 256
 	default "256"
 	---help---
 	  The maximum number of legacy PTYs that can be used at any one time.
 	  The default is 256, and should be more than enough.  Embedded
 	  systems may want to reduce this to save memory.
 	  When not in use, each legacy PTY occupies 12 bytes on 32-bit
 	  architectures and 24 bytes on 64-bit architectures.
 config BRIQ_PANEL
 	tristate 'Total Impact briQ front panel driver'
 	depends on PPC_CHRP
 	---help---
 	  The briQ is a small footprint CHRP computer with a frontpanel VFD, a
 	  tristate led and two switches. It is the size of a CDROM drive.
 	  If you have such one and want anything showing on the VFD then you
 	  must answer Y here.
 	  To compile this driver as a module, choose M here: the
 	  module will be called briq_panel.
 	  It's safe to say N here.
 config PRINTER
 	tristate "Parallel printer support"
 	depends on PARPORT
 	---help---
 	  If you intend to attach a printer to the parallel port of your Linux
 	  box (as opposed to using a serial printer; if the connector at the
 	  printer has 9 or 25 holes ["female"], then it's serial), say Y.
 	  Also read the Printing-HOWTO, available from
 	  <http://www.tldp.org/docs.html#howto>.
 	  It is possible to share one parallel port among several devices
 	  (e.g. printer and ZIP drive) and it is safe to compile the
 	  corresponding drivers into the kernel.
 	  To compile this driver as a module, choose M here and read
 	  <file:Documentation/parport.txt>.  The module will be called lp.
 	  If you have several parallel ports, you can specify which ports to
 	  use with the "lp" kernel command line option.  (Try "man bootparam"
 	  or see the documentation of your boot loader (lilo or loadlin) about
 	  how to pass options to the kernel at boot time.)  The syntax of the
 	  "lp" command line option can be found in <file:drivers/char/lp.c>.
 	  If you have more than 8 printers, you need to increase the LP_NO
 	  macro in lp.c and the PARPORT_MAX macro in parport.h.
 config LP_CONSOLE
 	bool "Support for console on line printer"
 	depends on PRINTER
 	---help---
 	  If you want kernel messages to be printed out as they occur, you
 	  can have a console on the printer. This option adds support for
 	  doing that; to actually get it to happen you need to pass the
 	  option "console=lp0" to the kernel at boot time.
 	  If the printer is out of paper (or off, or unplugged, or too
 	  busy..) the kernel will stall until the printer is ready again.
 	  By defining CONSOLE_LP_STRICT to 0 (at your own risk) you
 	  can make the kernel continue when this happens,
 	  but it'll lose the kernel messages.
 	  If unsure, say N.
 config PPDEV
 	tristate "Support for user-space parallel port device drivers"
 	depends on PARPORT
 	---help---
 	  Saying Y to this adds support for /dev/parport device nodes.  This
 	  is needed for programs that want portable access to the parallel
 	  port, for instance deviceid (which displays Plug-and-Play device
 	  IDs).
 	  This is the parallel port equivalent of SCSI generic support (sg).
 	  It is safe to say N to this -- it is not needed for normal printing
 	  or parallel port CD-ROM/disk support.
 	  To compile this driver as a module, choose M here: the
 	  module will be called ppdev.
 	  If unsure, say N.
 config TIPAR
 	tristate "Texas Instruments parallel link cable support"
 	depends on PARPORT
 	---help---
 	  If you own a Texas Instruments graphing calculator and use a
 	  parallel link cable, then you might be interested in this driver.
 	  If you enable this driver, you will be able to communicate with
 	  your calculator through a set of device nodes under /dev. The
 	  main advantage of this driver is that you don't have to be root
 	  to use this precise link cable (depending on the permissions on
 	  the device nodes, though).
 	  To compile this driver as a module, choose M here: the
 	  module will be called tipar.
 	  If you don't know what a parallel link cable is or what a Texas
 	  Instruments graphing calculator is, then you probably don't need this
 	  driver.
 	  If unsure, say N.
 config HVC_DRIVER
 	bool
 	help
 	  Users of pSeries machines that want to utilize the hvc console front-end
 	  module for their backend console driver should select this option.
 	  It will automatically be selected if one of the back-end console drivers
 	  is selected.
 config HVC_CONSOLE
 	bool "pSeries Hypervisor Virtual Console support"
 	depends on PPC_PSERIES
 	select HVC_DRIVER
 	help
 	  pSeries machines when partitioned support a hypervisor virtual
 	  console. This driver allows each pSeries partition to have a console
 	  which is accessed via the HMC.
 config HVC_ISERIES
 	bool "iSeries Hypervisor Virtual Console support"
 	depends on PPC_ISERIES
 	default y
 	select HVC_DRIVER
 	help
 	  iSeries machines support a hypervisor virtual console.
 config HVC_RTAS
 	bool "IBM RTAS Console support"
 	depends on PPC_RTAS
 	select HVC_DRIVER
 	help
 	  IBM Console device driver which makes use of RTAS
 config HVC_BEAT
 	bool "Toshiba's Beat Hypervisor Console support"
 	depends on PPC_CELLEB
 	select HVC_DRIVER
 	help
 	  Toshiba's Cell Reference Set Beat Console device driver
 config HVC_XEN
 	bool "Xen Hypervisor Console support"
 	depends on XEN
 	select HVC_DRIVER
 	default y
 	help
 	  Xen virtual console device driver
 config HVCS
 	tristate "IBM Hypervisor Virtual Console Server support"
 	depends on PPC_PSERIES
 	help
 	  Partitionable IBM Power5 ppc64 machines allow hosting of
 	  firmware virtual consoles from one Linux partition by
 	  another Linux partition.  This driver allows console data
 	  from Linux partitions to be accessed through TTY device
 	  interfaces in the device tree of a Linux partition running
 	  this driver.
 	  To compile this driver as a module, choose M here: the
 	  module will be called hvcs.ko.  Additionally, this module
 	  will depend on arch specific APIs exported from hvcserver.ko
 	  which will also be compiled when this driver is built as a
 	  module.
 source "drivers/char/ipmi/Kconfig"
 source "drivers/char/watchdog/Kconfig"
 config DS1620
 	tristate "NetWinder thermometer support"
 	depends on ARCH_NETWINDER
 	help
 	  Say Y here to include support for the thermal management hardware
 	  found in the NetWinder. This driver allows the user to control the
 	  temperature set points and to read the current temperature.
 	  It is also possible to say M here to build it as a module (ds1620)
 	  It is recommended to be used on a NetWinder, but it is not a
 	  necessity.
 config NWBUTTON
 	tristate "NetWinder Button"
 	depends on ARCH_NETWINDER
 	---help---
 	  If you say Y here and create a character device node /dev/nwbutton
 	  with major and minor numbers 10 and 158 ("man mknod"), then every
 	  time the orange button is pressed a number of times, the number of
 	  times the button was pressed will be written to that device.
 	  This is most useful for applications, as yet unwritten, which
 	  perform actions based on how many times the button is pressed in a
 	  row.
 	  Do not hold the button down for too long, as the driver does not
 	  alter the behaviour of the hardware reset circuitry attached to the
 	  button; it will still execute a hard reset if the button is held
 	  down for longer than approximately five seconds.
 	  To compile this driver as a module, choose M here: the
 	  module will be called nwbutton.
 	  Most people will answer Y to this question and "Reboot Using Button"
 	  below to be able to initiate a system shutdown from the button.
 config NWBUTTON_REBOOT
 	bool "Reboot Using Button"
 	depends on NWBUTTON
 	help
 	  If you say Y here, then you will be able to initiate a system
 	  shutdown and reboot by pressing the orange button a number of times.
 	  The number of presses to initiate the shutdown is two by default,
 	  but this can be altered by modifying the value of NUM_PRESSES_REBOOT
 	  in nwbutton.h and recompiling the driver or, if you compile the
 	  driver as a module, you can specify the number of presses at load
 	  time with "insmod button reboot_count=<something>".
 config NWFLASH
 	tristate "NetWinder flash support"
 	depends on ARCH_NETWINDER
 	---help---
 	  If you say Y here and create a character device /dev/flash with
 	  major 10 and minor 160 you can manipulate the flash ROM containing
 	  the NetWinder firmware. Be careful as accidentally overwriting the
 	  flash contents can render your computer unbootable. On no account
 	  allow random users access to this device. :-)
 	  To compile this driver as a module, choose M here: the
 	  module will be called nwflash.
 	  If you're not sure, say N.
 source "drivers/char/hw_random/Kconfig"
 config NVRAM
 	tristate "/dev/nvram support"
 	depends on ATARI || X86 || ARM || GENERIC_NVRAM
 	---help---
 	  If you say Y here and create a character special file /dev/nvram
 	  with major number 10 and minor number 144 using mknod ("man mknod"),
 	  you get read and write access to the extra bytes of non-volatile
 	  memory in the real time clock (RTC), which is contained in every PC
 	  and most Ataris.  The actual number of bytes varies, depending on the
 	  nvram in the system, but is usually 114 (128-14 for the RTC).
 	  This memory is conventionally called "CMOS RAM" on PCs and "NVRAM"
 	  on Ataris. /dev/nvram may be used to view settings there, or to
 	  change them (with some utility). It could also be used to frequently
 	  save a few bits of very important data that may not be lost over
 	  power-off and for which writing to disk is too insecure. Note
 	  however that most NVRAM space in a PC belongs to the BIOS and you
 	  should NEVER idly tamper with it. See Ralf Brown's interrupt list
 	  for a guide to the use of CMOS bytes by your BIOS.
 	  On Atari machines, /dev/nvram is always configured and does not need
 	  to be selected.
 	  To compile this driver as a module, choose M here: the
 	  module will be called nvram.
 config RTC
 	tristate "Enhanced Real Time Clock Support"
 	depends on !PPC && !PARISC && !IA64 && !M68K && !SPARC && !FRV && !ARM && !SUPERH && !S390
 	---help---
 	  If you say Y here and create a character special file /dev/rtc with
 	  major number 10 and minor number 135 using mknod ("man mknod"), you
 	  will get access to the real time clock (or hardware clock) built
 	  into your computer.
 	  Every PC has such a clock built in. It can be used to generate
 	  signals from as low as 1Hz up to 8192Hz, and can also be used
 	  as a 24 hour alarm. It reports status information via the file
 	  /proc/driver/rtc and its behaviour is set by various ioctls on
 	  /dev/rtc.
 	  If you run Linux on a multiprocessor machine and said Y to
 	  "Symmetric Multi Processing" above, you should say Y here to read
 	  and set the RTC in an SMP compatible fashion.
 	  If you think you have a use for such a device (such as periodic data
 	  sampling), then say Y here, and read <file:Documentation/rtc.txt>
 	  for details.
 	  To compile this driver as a module, choose M here: the
 	  module will be called rtc.
 config JS_RTC
 	tristate "Enhanced Real Time Clock Support"
 	depends on SPARC32 && PCI
 	---help---
 	  If you say Y here and create a character special file /dev/rtc with
 	  major number 10 and minor number 135 using mknod ("man mknod"), you
 	  will get access to the real time clock (or hardware clock) built
 	  into your computer.
 	  Every PC has such a clock built in. It can be used to generate
 	  signals from as low as 1Hz up to 8192Hz, and can also be used
 	  as a 24 hour alarm. It reports status information via the file
 	  /proc/driver/rtc and its behaviour is set by various ioctls on
 	  /dev/rtc.
 	  If you think you have a use for such a device (such as periodic data
 	  sampling), then say Y here, and read <file:Documentation/rtc.txt>
 	  for details.
 	  To compile this driver as a module, choose M here: the
 	  module will be called js-rtc.
 config SGI_DS1286
 	tristate "SGI DS1286 RTC support"
 	depends on SGI_IP22
 	help
 	  If you say Y here and create a character special file /dev/rtc with
 	  major number 10 and minor number 135 using mknod ("man mknod"), you
 	  will get access to the real time clock built into your computer.
 	  Every SGI has such a clock built in. It reports status information
 	  via the file /proc/rtc and its behaviour is set by various ioctls on
 	  /dev/rtc.
 config SGI_IP27_RTC
 	bool "SGI M48T35 RTC support"
 	depends on SGI_IP27
 	help
 	  If you say Y here and create a character special file /dev/rtc with
 	  major number 10 and minor number 135 using mknod ("man mknod"), you
 	  will get access to the real time clock built into your computer.
 	  Every SGI has such a clock built in. It reports status information
 	  via the file /proc/rtc and its behaviour is set by various ioctls on
 	  /dev/rtc.
 config GEN_RTC
 	tristate "Generic /dev/rtc emulation"
 	depends on RTC!=y && !IA64 && !ARM && !M32R && !MIPS && !SPARC && !FRV && !S390 && !SUPERH
 	---help---
 	  If you say Y here and create a character special file /dev/rtc with
 	  major number 10 and minor number 135 using mknod ("man mknod"), you
 	  will get access to the real time clock (or hardware clock) built
 	  into your computer.
 	  It reports status information via the file /proc/driver/rtc and its
 	  behaviour is set by various ioctls on /dev/rtc. If you enable the
 	  "extended RTC operation" below it will also provide an emulation
 	  for RTC_UIE which is required by some programs and may improve
 	  precision in some cases.
 	  To compile this driver as a module, choose M here: the
 	  module will be called genrtc.
 config GEN_RTC_X
 	bool "Extended RTC operation"
 	depends on GEN_RTC
 	help
 	  Provides an emulation for RTC_UIE which is required by some programs
 	  and may improve precision of the generic RTC support in some cases.
 config EFI_RTC
 	bool "EFI Real Time Clock Services"
 	depends on IA64
 config DS1302
 	tristate "DS1302 RTC support"
 	depends on M32R && (PLAT_M32700UT || PLAT_OPSPUT)
 	help
 	  If you say Y here and create a character special file /dev/rtc with
 	  major number 121 and minor number 0 using mknod ("man mknod"), you
 	  will get access to the real time clock (or hardware clock) built
 	  into your computer.
 config COBALT_LCD
 	bool "Support for Cobalt LCD"
 	depends on MIPS_COBALT
 	help
 	  This option enables support for the LCD display and buttons found
 	  on Cobalt systems through a misc device.
 config DTLK
 	tristate "Double Talk PC internal speech card support"
 	depends on ISA
 	help
 	  This driver is for the DoubleTalk PC, a speech synthesizer
 	  manufactured by RC Systems (<http://www.rcsys.com/>).  It is also
 	  called the `internal DoubleTalk'.
 	  To compile this driver as a module, choose M here: the
 	  module will be called dtlk.
 config R3964
 	tristate "Siemens R3964 line discipline"
 	---help---
 	  This driver allows synchronous communication with devices using the
 	  Siemens R3964 packet protocol. Unless you are dealing with special
 	  hardware like PLCs, you are unlikely to need this.
 	  To compile this driver as a module, choose M here: the
 	  module will be called n_r3964.
 	  If unsure, say N.
 config APPLICOM
 	tristate "Applicom intelligent fieldbus card support"
 	depends on PCI
 	---help---
 	  This driver provides the kernel-side support for the intelligent
 	  fieldbus cards made by Applicom International. More information
 	  about these cards can be found on the WWW at the address
 	  <http://www.applicom-int.com/>, or by email from David Woodhouse
 	  <dwmw2@infradead.org>.
 	  To compile this driver as a module, choose M here: the
 	  module will be called applicom.
 	  If unsure, say N.
 config SONYPI
 	tristate "Sony Vaio Programmable I/O Control Device support (EXPERIMENTAL)"
 	depends on EXPERIMENTAL && X86 && PCI && INPUT && !64BIT
 	---help---
 	  This driver enables access to the Sony Programmable I/O Control
 	  Device which can be found in many (all ?) Sony Vaio laptops.
 	  If you have one of those laptops, read
 	  <file:Documentation/sonypi.txt>, and say Y or M here.
 	  To compile this driver as a module, choose M here: the
 	  module will be called sonypi.
 config GPIO_TB0219
 	tristate "TANBAC TB0219 GPIO support"
 	depends on TANBAC_TB022X
 	select GPIO_VR41XX
 source "drivers/char/pcmcia/Kconfig"
 config MWAVE
 	tristate "ACP Modem (Mwave) support"
 	depends on X86
 	select SERIAL_8250
 	---help---
 	  The ACP modem (Mwave) for Linux is a WinModem. It is composed of a
 	  kernel driver and a user level application. Together these components
 	  support direct attachment to public switched telephone networks (PSTNs)
 	  and support selected world wide countries.
 	  This version of the ACP Modem driver supports the IBM Thinkpad 600E,
 	  600, and 770 that include on board ACP modem hardware.
 	  The modem also supports the standard communications port interface
 	  (ttySx) and is compatible with the Hayes AT Command Set.
 	  The user level application needed to use this driver can be found at
 	  the IBM Linux Technology Center (LTC) web site:
 	  <http://www.ibm.com/linux/ltc/>.
 	  If you own one of the above IBM Thinkpads which has the Mwave chipset
 	  in it, say Y.
 	  To compile this driver as a module, choose M here: the
 	  module will be called mwave.
 config SCx200_GPIO
 	tristate "NatSemi SCx200 GPIO Support"
 	depends on SCx200
 	select NSC_GPIO
 	help
 	  Give userspace access to the GPIO pins on the National
 	  Semiconductor SCx200 processors.
 	  If compiled as a module, it will be called scx200_gpio.
 config PC8736x_GPIO
 	tristate "NatSemi PC8736x GPIO Support"
 	depends on X86
 	default SCx200_GPIO	# mostly N
 	select NSC_GPIO		# needed for support routines
 	help
 	  Give userspace access to the GPIO pins on the National
 	  Semiconductor PC-8736x (x=[03456]) SuperIO chip.  The chip
 	  has multiple functional units, inc several managed by
 	  hwmon/pc87360 driver.  Tested with PC-87366
 	  If compiled as a module, it will be called pc8736x_gpio.
 config NSC_GPIO
 	tristate "NatSemi Base GPIO Support"
 	depends on X86_32
 	# selected by SCx200_GPIO and PC8736x_GPIO
 	# what about 2 selectors differing: m != y
 	help
 	  Common support used (and needed) by scx200_gpio and
 	  pc8736x_gpio drivers.  If those drivers are built as
 	  modules, this one will be too, named nsc_gpio
 config CS5535_GPIO
 	tristate "AMD CS5535/CS5536 GPIO (Geode Companion Device)"
 	depends on X86_32
 	help
 	  Give userspace access to the GPIO pins on the AMD CS5535 and
 	  CS5536 Geode companion devices.
 	  If compiled as a module, it will be called cs5535_gpio.
 config GPIO_VR41XX
 	tristate "NEC VR4100 series General-purpose I/O Unit support"
 	depends on CPU_VR41XX
 config RAW_DRIVER
 	tristate "RAW driver (/dev/raw/rawN)"
 	depends on BLOCK
 	help
 	  The raw driver permits block devices to be bound to /dev/raw/rawN.
 	  Once bound, I/O against /dev/raw/rawN uses efficient zero-copy I/O.
 	  See the raw(8) manpage for more details.
           Applications should preferably open the device (eg /dev/hda1)
           with the O_DIRECT flag.
 config MAX_RAW_DEVS
 	int "Maximum number of RAW devices to support (1-8192)"
 	depends on RAW_DRIVER
 	default "256"
 	help
 	  The maximum number of RAW devices that are supported.
 	  Default is 256. Increase this number in case you need lots of
 	  raw devices.
 config HPET
 	bool "HPET - High Precision Event Timer" if (X86 || IA64)
 	default n
 	depends on ACPI
 	help
 	  If you say Y here, you will have a miscdevice named "/dev/hpet/".  Each
 	  open selects one of the timers supported by the HPET.  The timers are
 	  non-periodic and/or periodic.
 config HPET_RTC_IRQ
 	bool "HPET Control RTC IRQ" if !HPET_EMULATE_RTC
 	default n
 	depends on HPET
 	help
 	  If you say Y here, you will disable RTC_IRQ in drivers/char/rtc.c. It
 	  is assumed the platform called hpet_alloc with the RTC IRQ values for
 	  the HPET timers.
 config HPET_MMAP
 	bool "Allow mmap of HPET"
 	default y
 	depends on HPET
 	help
 	  If you say Y here, user applications will be able to mmap
 	  the HPET registers.
 	  In some hardware implementations, the page containing HPET
 	  registers may also contain other things that shouldn't be
 	  exposed to the user.  If this applies to your hardware,
 	  say N here.
 config HANGCHECK_TIMER
 	tristate "Hangcheck timer"
 	depends on X86 || IA64 || PPC64 || S390
 	help
 	  The hangcheck-timer module detects when the system has gone
 	  out to lunch past a certain margin.  It can reboot the system
 	  or merely print a warning.
 config MMTIMER
 	tristate "MMTIMER Memory mapped RTC for SGI Altix"
 	depends on IA64_GENERIC || IA64_SGI_SN2
 	default y
 	help
 	  The mmtimer device allows direct userspace access to the
 	  Altix system timer.
 source "drivers/char/tpm/Kconfig"
 config TELCLOCK
 	tristate "Telecom clock driver for ATCA SBC"
 	depends on EXPERIMENTAL && X86
 	default n
 	help
 	  The telecom clock device is specific to the MPCBL0010 and MPCBL0050
 	  ATCA computers and allows direct userspace access to the
 	  configuration of the telecom clock configuration settings.  This
 	  device is used for hardware synchronization across the ATCA backplane
 	  fabric.  Upon loading, the driver exports a sysfs directory,
 	  /sys/devices/platform/telco_clock, with a number of files for
 	  controlling the behavior of this hardware.
 config DEVPORT
 	bool
 	depends on !M68K
 	depends on ISA || PCI
 	default y
 source "drivers/s390/char/Kconfig"
 endmenu

drivers/char/keyboard.c

Diff comments View file @ 2e8ecb9

1	/*	1	/*
2	* linux/drivers/char/keyboard.c	2	* linux/drivers/char/keyboard.c
3	*	3	*
4	* Written for linux by Johan Myreen as a translation from	4	* Written for linux by Johan Myreen as a translation from
5	* the assembly version by Linus (with diacriticals added)	5	* the assembly version by Linus (with diacriticals added)
6	*	6	*
7	* Some additional features added by Christoph Niemann (ChN), March 1993	7	* Some additional features added by Christoph Niemann (ChN), March 1993
8	*	8	*
9	* Loadable keymaps by Risto Kankkunen, May 1993	9	* Loadable keymaps by Risto Kankkunen, May 1993
10	*	10	*
11	* Diacriticals redone & other small changes, aeb@cwi.nl, June 1993	11	* Diacriticals redone & other small changes, aeb@cwi.nl, June 1993
12	* Added decr/incr_console, dynamic keymaps, Unicode support,	12	* Added decr/incr_console, dynamic keymaps, Unicode support,
13	* dynamic function/string keys, led setting, Sept 1994	13	* dynamic function/string keys, led setting, Sept 1994
14	* `Sticky' modifier keys, 951006.	14	* `Sticky' modifier keys, 951006.
15	*	15	*
16	* 11-11-96: SAK should now work in the raw mode (Martin Mares)	16	* 11-11-96: SAK should now work in the raw mode (Martin Mares)
17	*	17	*
18	* Modified to provide 'generic' keyboard support by Hamish Macdonald	18	* Modified to provide 'generic' keyboard support by Hamish Macdonald
19	* Merge with the m68k keyboard driver and split-off of the PC low-level	19	* Merge with the m68k keyboard driver and split-off of the PC low-level
20	* parts by Geert Uytterhoeven, May 1997	20	* parts by Geert Uytterhoeven, May 1997
21	*	21	*
22	* 27-05-97: Added support for the Magic SysRq Key (Martin Mares)	22	* 27-05-97: Added support for the Magic SysRq Key (Martin Mares)
23	* 30-07-98: Dead keys redone, aeb@cwi.nl.	23	* 30-07-98: Dead keys redone, aeb@cwi.nl.
24	* 21-08-02: Converted to input API, major cleanup. (Vojtech Pavlik)	24	* 21-08-02: Converted to input API, major cleanup. (Vojtech Pavlik)
25	*/	25	*/
26		26
27	#include <linux/consolemap.h>	27	#include <linux/consolemap.h>
28	#include <linux/module.h>	28	#include <linux/module.h>
29	#include <linux/sched.h>	29	#include <linux/sched.h>
30	#include <linux/tty.h>	30	#include <linux/tty.h>
31	#include <linux/tty_flip.h>	31	#include <linux/tty_flip.h>
32	#include <linux/mm.h>	32	#include <linux/mm.h>
33	#include <linux/string.h>	33	#include <linux/string.h>
34	#include <linux/init.h>	34	#include <linux/init.h>
35	#include <linux/slab.h>	35	#include <linux/slab.h>
36	#include <linux/irq.h>	36	#include <linux/irq.h>
37		37
38	#include <linux/kbd_kern.h>	38	#include <linux/kbd_kern.h>
39	#include <linux/kbd_diacr.h>	39	#include <linux/kbd_diacr.h>
40	#include <linux/vt_kern.h>	40	#include <linux/vt_kern.h>
41	#include <linux/consolemap.h>	41	#include <linux/consolemap.h>
42	#include <linux/sysrq.h>	42	#include <linux/sysrq.h>
43	#include <linux/input.h>	43	#include <linux/input.h>
44	#include <linux/reboot.h>	44	#include <linux/reboot.h>
45		45
46	extern void ctrl_alt_del(void);	46	extern void ctrl_alt_del(void);
47		47
48	/*	48	/*
49	* Exported functions/variables	49	* Exported functions/variables
50	*/	50	*/
51		51
52	#define KBD_DEFMODE ((1 << VC_REPEAT) \| (1 << VC_META))	52	#define KBD_DEFMODE ((1 << VC_REPEAT) \| (1 << VC_META))
53		53
54	/*	54	/*
55	* Some laptops take the 789uiojklm,. keys as number pad when NumLock is on.	55	* Some laptops take the 789uiojklm,. keys as number pad when NumLock is on.
56	* This seems a good reason to start with NumLock off. On HIL keyboards	56	* This seems a good reason to start with NumLock off. On HIL keyboards
57	* of PARISC machines however there is no NumLock key and everyone expects the keypad	57	* of PARISC machines however there is no NumLock key and everyone expects the keypad
58	* to be used for numbers.	58	* to be used for numbers.
59	*/	59	*/
60		60
61	#if defined(CONFIG_PARISC) && (defined(CONFIG_KEYBOARD_HIL) \|\| defined(CONFIG_KEYBOARD_HIL_OLD))	61	#if defined(CONFIG_PARISC) && (defined(CONFIG_KEYBOARD_HIL) \|\| defined(CONFIG_KEYBOARD_HIL_OLD))
62	#define KBD_DEFLEDS (1 << VC_NUMLOCK)	62	#define KBD_DEFLEDS (1 << VC_NUMLOCK)
63	#else	63	#else
64	#define KBD_DEFLEDS 0	64	#define KBD_DEFLEDS 0
65	#endif	65	#endif
66		66
67	#define KBD_DEFLOCK 0	67	#define KBD_DEFLOCK 0
68		68
69	void compute_shiftstate(void);	69	void compute_shiftstate(void);
70		70
71	/*	71	/*
72	* Handler Tables.	72	* Handler Tables.
73	*/	73	*/
74		74
75	#define K_HANDLERS\	75	#define K_HANDLERS\
76	k_self, k_fn, k_spec, k_pad,\	76	k_self, k_fn, k_spec, k_pad,\
77	k_dead, k_cons, k_cur, k_shift,\	77	k_dead, k_cons, k_cur, k_shift,\
78	k_meta, k_ascii, k_lock, k_lowercase,\	78	k_meta, k_ascii, k_lock, k_lowercase,\
79	k_slock, k_dead2, k_brl, k_ignore	79	k_slock, k_dead2, k_brl, k_ignore
80		80
81	typedef void (k_handler_fn)(struct vc_data *vc, unsigned char value,	81	typedef void (k_handler_fn)(struct vc_data *vc, unsigned char value,
82	char up_flag);	82	char up_flag);
83	static k_handler_fn K_HANDLERS;	83	static k_handler_fn K_HANDLERS;
84	static k_handler_fn *k_handler[16] = { K_HANDLERS };	84	static k_handler_fn *k_handler[16] = { K_HANDLERS };
85		85
86	#define FN_HANDLERS\	86	#define FN_HANDLERS\
87	fn_null, fn_enter, fn_show_ptregs, fn_show_mem,\	87	fn_null, fn_enter, fn_show_ptregs, fn_show_mem,\
88	fn_show_state, fn_send_intr, fn_lastcons, fn_caps_toggle,\	88	fn_show_state, fn_send_intr, fn_lastcons, fn_caps_toggle,\
89	fn_num, fn_hold, fn_scroll_forw, fn_scroll_back,\	89	fn_num, fn_hold, fn_scroll_forw, fn_scroll_back,\
90	fn_boot_it, fn_caps_on, fn_compose, fn_SAK,\	90	fn_boot_it, fn_caps_on, fn_compose, fn_SAK,\
91	fn_dec_console, fn_inc_console, fn_spawn_con, fn_bare_num	91	fn_dec_console, fn_inc_console, fn_spawn_con, fn_bare_num
92		92
93	typedef void (fn_handler_fn)(struct vc_data *vc);	93	typedef void (fn_handler_fn)(struct vc_data *vc);
94	static fn_handler_fn FN_HANDLERS;	94	static fn_handler_fn FN_HANDLERS;
95	static fn_handler_fn *fn_handler[] = { FN_HANDLERS };	95	static fn_handler_fn *fn_handler[] = { FN_HANDLERS };
96		96
97	/*	97	/*
98	* Variables exported for vt_ioctl.c	98	* Variables exported for vt_ioctl.c
99	*/	99	*/
100		100
101	/* maximum values each key_handler can handle */	101	/* maximum values each key_handler can handle */
102	const int max_vals[] = {	102	const int max_vals[] = {
103	255, ARRAY_SIZE(func_table) - 1, ARRAY_SIZE(fn_handler) - 1, NR_PAD - 1,	103	255, ARRAY_SIZE(func_table) - 1, ARRAY_SIZE(fn_handler) - 1, NR_PAD - 1,
104	NR_DEAD - 1, 255, 3, NR_SHIFT - 1, 255, NR_ASCII - 1, NR_LOCK - 1,	104	NR_DEAD - 1, 255, 3, NR_SHIFT - 1, 255, NR_ASCII - 1, NR_LOCK - 1,
105	255, NR_LOCK - 1, 255, NR_BRL - 1	105	255, NR_LOCK - 1, 255, NR_BRL - 1
106	};	106	};
107		107
108	const int NR_TYPES = ARRAY_SIZE(max_vals);	108	const int NR_TYPES = ARRAY_SIZE(max_vals);
109		109
110	struct kbd_struct kbd_table[MAX_NR_CONSOLES];	110	struct kbd_struct kbd_table[MAX_NR_CONSOLES];
111	static struct kbd_struct *kbd = kbd_table;	111	static struct kbd_struct *kbd = kbd_table;
112		112
113	struct vt_spawn_console vt_spawn_con = {	113	struct vt_spawn_console vt_spawn_con = {
114	.lock = __SPIN_LOCK_UNLOCKED(vt_spawn_con.lock),	114	.lock = __SPIN_LOCK_UNLOCKED(vt_spawn_con.lock),
115	.pid = NULL,	115	.pid = NULL,
116	.sig = 0,	116	.sig = 0,
117	};	117	};
118		118
119	/*	119	/*
120	* Variables exported for vt.c	120	* Variables exported for vt.c
121	*/	121	*/
122		122
123	int shift_state = 0;	123	int shift_state = 0;
124		124
125	/*	125	/*
126	* Internal Data.	126	* Internal Data.
127	*/	127	*/
128		128
129	static struct input_handler kbd_handler;	129	static struct input_handler kbd_handler;
130	static unsigned long key_down[NBITS(KEY_MAX)]; /* keyboard key bitmap */	130	static unsigned long key_down[NBITS(KEY_MAX)]; /* keyboard key bitmap */
131	static unsigned char shift_down[NR_SHIFT]; /* shift state counters.. */	131	static unsigned char shift_down[NR_SHIFT]; /* shift state counters.. */
132	static int dead_key_next;	132	static int dead_key_next;
133	static int npadch = -1; /* -1 or number assembled on pad */	133	static int npadch = -1; /* -1 or number assembled on pad */
134	static unsigned int diacr;	134	static unsigned int diacr;
135	static char rep; /* flag telling character repeat */	135	static char rep; /* flag telling character repeat */
136		136
137	static unsigned char ledstate = 0xff; /* undefined */	137	static unsigned char ledstate = 0xff; /* undefined */
138	static unsigned char ledioctl;	138	static unsigned char ledioctl;
139		139
140	static struct ledptr {	140	static struct ledptr {
141	unsigned int *addr;	141	unsigned int *addr;
142	unsigned int mask;	142	unsigned int mask;
143	unsigned char valid:1;	143	unsigned char valid:1;
144	} ledptrs[3];	144	} ledptrs[3];
145		145
146	/* Simple translation table for the SysRq keys */	146	/* Simple translation table for the SysRq keys */
147		147
148	#ifdef CONFIG_MAGIC_SYSRQ	148	#ifdef CONFIG_MAGIC_SYSRQ
149	unsigned char kbd_sysrq_xlate[KEY_MAX + 1] =	149	unsigned char kbd_sysrq_xlate[KEY_MAX + 1] =
150	"\000\0331234567890-=\177\t" /* 0x00 - 0x0f */	150	"\000\0331234567890-=\177\t" /* 0x00 - 0x0f */
151	"qwertyuiop[]\r\000as" /* 0x10 - 0x1f */	151	"qwertyuiop[]\r\000as" /* 0x10 - 0x1f */
152	"dfghjkl;'`\000\\zxcv" /* 0x20 - 0x2f */	152	"dfghjkl;'`\000\\zxcv" /* 0x20 - 0x2f */
153	"bnm,./\000\000 \000\201\202\203\204\205" / 0x30 - 0x3f */	153	"bnm,./\000\000 \000\201\202\203\204\205" / 0x30 - 0x3f */
154	"\206\207\210\211\212\000\000789-456+1" /* 0x40 - 0x4f */	154	"\206\207\210\211\212\000\000789-456+1" /* 0x40 - 0x4f */
155	"230\177\000\000\213\214\000\000\000\000\000\000\000\000\000\000" /* 0x50 - 0x5f */	155	"230\177\000\000\213\214\000\000\000\000\000\000\000\000\000\000" /* 0x50 - 0x5f */
156	"\r\000/"; /* 0x60 - 0x6f */	156	"\r\000/"; /* 0x60 - 0x6f */
157	static int sysrq_down;	157	static int sysrq_down;
158	static int sysrq_alt_use;	158	static int sysrq_alt_use;
159	#endif	159	#endif
160	static int sysrq_alt;	160	static int sysrq_alt;
161		161
162	/*	162	/*
163	* Translation of scancodes to keycodes. We set them on only the first	163	* Translation of scancodes to keycodes. We set them on only the first
164	* keyboard in the list that accepts the scancode and keycode.	164	* keyboard in the list that accepts the scancode and keycode.
165	* Explanation for not choosing the first attached keyboard anymore:	165	* Explanation for not choosing the first attached keyboard anymore:
166	* USB keyboards for example have two event devices: one for all "normal"	166	* USB keyboards for example have two event devices: one for all "normal"
167	* keys and one for extra function keys (like "volume up", "make coffee",	167	* keys and one for extra function keys (like "volume up", "make coffee",
168	* etc.). So this means that scancodes for the extra function keys won't	168	* etc.). So this means that scancodes for the extra function keys won't
169	* be valid for the first event device, but will be for the second.	169	* be valid for the first event device, but will be for the second.
170	*/	170	*/
171	int getkeycode(unsigned int scancode)	171	int getkeycode(unsigned int scancode)
172	{	172	{
173	struct input_handle *handle;	173	struct input_handle *handle;
174	int keycode;	174	int keycode;
175	int error = -ENODEV;	175	int error = -ENODEV;
176		176
177	list_for_each_entry(handle, &kbd_handler.h_list, h_node) {	177	list_for_each_entry(handle, &kbd_handler.h_list, h_node) {
178	error = handle->dev->getkeycode(handle->dev, scancode, &keycode);	178	error = handle->dev->getkeycode(handle->dev, scancode, &keycode);
179	if (!error)	179	if (!error)
180	return keycode;	180	return keycode;
181	}	181	}
182		182
183	return error;	183	return error;
184	}	184	}
185		185
186	int setkeycode(unsigned int scancode, unsigned int keycode)	186	int setkeycode(unsigned int scancode, unsigned int keycode)
187	{	187	{
188	struct input_handle *handle;	188	struct input_handle *handle;
189	int error = -ENODEV;	189	int error = -ENODEV;
190		190
191	list_for_each_entry(handle, &kbd_handler.h_list, h_node) {	191	list_for_each_entry(handle, &kbd_handler.h_list, h_node) {
192	error = handle->dev->setkeycode(handle->dev, scancode, keycode);	192	error = handle->dev->setkeycode(handle->dev, scancode, keycode);
193	if (!error)	193	if (!error)
194	break;	194	break;
195	}	195	}
196		196
197	return error;	197	return error;
198	}	198	}
199		199
200	/*	200	/*
201	* Making beeps and bells.	201	* Making beeps and bells.
202	*/	202	*/
203	static void kd_nosound(unsigned long ignored)	203	static void kd_nosound(unsigned long ignored)
204	{	204	{
205	struct input_handle *handle;	205	struct input_handle *handle;
206		206
207	list_for_each_entry(handle, &kbd_handler.h_list, h_node) {	207	list_for_each_entry(handle, &kbd_handler.h_list, h_node) {
208	if (test_bit(EV_SND, handle->dev->evbit)) {	208	if (test_bit(EV_SND, handle->dev->evbit)) {
209	if (test_bit(SND_TONE, handle->dev->sndbit))	209	if (test_bit(SND_TONE, handle->dev->sndbit))
210	input_inject_event(handle, EV_SND, SND_TONE, 0);	210	input_inject_event(handle, EV_SND, SND_TONE, 0);
211	if (test_bit(SND_BELL, handle->dev->sndbit))	211	if (test_bit(SND_BELL, handle->dev->sndbit))
212	input_inject_event(handle, EV_SND, SND_BELL, 0);	212	input_inject_event(handle, EV_SND, SND_BELL, 0);
213	}	213	}
214	}	214	}
215	}	215	}
216		216
217	static DEFINE_TIMER(kd_mksound_timer, kd_nosound, 0, 0);	217	static DEFINE_TIMER(kd_mksound_timer, kd_nosound, 0, 0);
218		218
219	void kd_mksound(unsigned int hz, unsigned int ticks)	219	void kd_mksound(unsigned int hz, unsigned int ticks)
220	{	220	{
221	struct list_head *node;	221	struct list_head *node;
222		222
223	del_timer(&kd_mksound_timer);	223	del_timer(&kd_mksound_timer);
224		224
225	if (hz) {	225	if (hz) {
226	list_for_each_prev(node, &kbd_handler.h_list) {	226	list_for_each_prev(node, &kbd_handler.h_list) {
227	struct input_handle *handle = to_handle_h(node);	227	struct input_handle *handle = to_handle_h(node);
228	if (test_bit(EV_SND, handle->dev->evbit)) {	228	if (test_bit(EV_SND, handle->dev->evbit)) {
229	if (test_bit(SND_TONE, handle->dev->sndbit)) {	229	if (test_bit(SND_TONE, handle->dev->sndbit)) {
230	input_inject_event(handle, EV_SND, SND_TONE, hz);	230	input_inject_event(handle, EV_SND, SND_TONE, hz);
231	break;	231	break;
232	}	232	}
233	if (test_bit(SND_BELL, handle->dev->sndbit)) {	233	if (test_bit(SND_BELL, handle->dev->sndbit)) {
234	input_inject_event(handle, EV_SND, SND_BELL, 1);	234	input_inject_event(handle, EV_SND, SND_BELL, 1);
235	break;	235	break;
236	}	236	}
237	}	237	}
238	}	238	}
239	if (ticks)	239	if (ticks)
240	mod_timer(&kd_mksound_timer, jiffies + ticks);	240	mod_timer(&kd_mksound_timer, jiffies + ticks);
241	} else	241	} else
242	kd_nosound(0);	242	kd_nosound(0);
243	}	243	}
244		244
245	/*	245	/*
246	* Setting the keyboard rate.	246	* Setting the keyboard rate.
247	*/	247	*/
248		248
249	int kbd_rate(struct kbd_repeat *rep)	249	int kbd_rate(struct kbd_repeat *rep)
250	{	250	{
251	struct list_head *node;	251	struct list_head *node;
252	unsigned int d = 0;	252	unsigned int d = 0;
253	unsigned int p = 0;	253	unsigned int p = 0;
254		254
255	list_for_each(node, &kbd_handler.h_list) {	255	list_for_each(node, &kbd_handler.h_list) {
256	struct input_handle *handle = to_handle_h(node);	256	struct input_handle *handle = to_handle_h(node);
257	struct input_dev *dev = handle->dev;	257	struct input_dev *dev = handle->dev;
258		258
259	if (test_bit(EV_REP, dev->evbit)) {	259	if (test_bit(EV_REP, dev->evbit)) {
260	if (rep->delay > 0)	260	if (rep->delay > 0)
261	input_inject_event(handle, EV_REP, REP_DELAY, rep->delay);	261	input_inject_event(handle, EV_REP, REP_DELAY, rep->delay);
262	if (rep->period > 0)	262	if (rep->period > 0)
263	input_inject_event(handle, EV_REP, REP_PERIOD, rep->period);	263	input_inject_event(handle, EV_REP, REP_PERIOD, rep->period);
264	d = dev->rep[REP_DELAY];	264	d = dev->rep[REP_DELAY];
265	p = dev->rep[REP_PERIOD];	265	p = dev->rep[REP_PERIOD];
266	}	266	}
267	}	267	}
268	rep->delay = d;	268	rep->delay = d;
269	rep->period = p;	269	rep->period = p;
270	return 0;	270	return 0;
271	}	271	}
272		272
273	/*	273	/*
274	* Helper Functions.	274	* Helper Functions.
275	*/	275	*/
276	static void put_queue(struct vc_data *vc, int ch)	276	static void put_queue(struct vc_data *vc, int ch)
277	{	277	{
278	struct tty_struct *tty = vc->vc_tty;	278	struct tty_struct *tty = vc->vc_tty;
279		279
280	if (tty) {	280	if (tty) {
281	tty_insert_flip_char(tty, ch, 0);	281	tty_insert_flip_char(tty, ch, 0);
282	con_schedule_flip(tty);	282	con_schedule_flip(tty);
283	}	283	}
284	}	284	}
285		285
286	static void puts_queue(struct vc_data vc, char cp)	286	static void puts_queue(struct vc_data vc, char cp)
287	{	287	{
288	struct tty_struct *tty = vc->vc_tty;	288	struct tty_struct *tty = vc->vc_tty;
289		289
290	if (!tty)	290	if (!tty)
291	return;	291	return;
292		292
293	while (*cp) {	293	while (*cp) {
294	tty_insert_flip_char(tty, *cp, 0);	294	tty_insert_flip_char(tty, *cp, 0);
295	cp++;	295	cp++;
296	}	296	}
297	con_schedule_flip(tty);	297	con_schedule_flip(tty);
298	}	298	}
299		299
300	static void applkey(struct vc_data *vc, int key, char mode)	300	static void applkey(struct vc_data *vc, int key, char mode)
301	{	301	{
302	static char buf[] = { 0x1b, 'O', 0x00, 0x00 };	302	static char buf[] = { 0x1b, 'O', 0x00, 0x00 };
303		303
304	buf[1] = (mode ? 'O' : '[');	304	buf[1] = (mode ? 'O' : '[');
305	buf[2] = key;	305	buf[2] = key;
306	puts_queue(vc, buf);	306	puts_queue(vc, buf);
307	}	307	}
308		308
309	/*	309	/*
310	* Many other routines do put_queue, but I think either	310	* Many other routines do put_queue, but I think either
311	* they produce ASCII, or they produce some user-assigned	311	* they produce ASCII, or they produce some user-assigned
312	* string, and in both cases we might assume that it is	312	* string, and in both cases we might assume that it is
313	* in utf-8 already.	313	* in utf-8 already.
314	*/	314	*/
315	static void to_utf8(struct vc_data *vc, uint c)	315	static void to_utf8(struct vc_data *vc, uint c)
316	{	316	{
317	if (c < 0x80)	317	if (c < 0x80)
318	/* 0******* */	318	/* 0******* */
319	put_queue(vc, c);	319	put_queue(vc, c);
320	else if (c < 0x800) {	320	else if (c < 0x800) {
321	/* 110*** 10**** */	321	/* 110*** 10**** */
322	put_queue(vc, 0xc0 \| (c >> 6));	322	put_queue(vc, 0xc0 \| (c >> 6));
323	put_queue(vc, 0x80 \| (c & 0x3f));	323	put_queue(vc, 0x80 \| (c & 0x3f));
324	} else if (c < 0x10000) {	324	} else if (c < 0x10000) {
325	if (c >= 0xD800 && c < 0xE000)	325	if (c >= 0xD800 && c < 0xE000)
326	return;	326	return;
327	if (c == 0xFFFF)	327	if (c == 0xFFFF)
328	return;	328	return;
329	/* 1110** 10** 10**** */	329	/* 1110** 10** 10**** */
330	put_queue(vc, 0xe0 \| (c >> 12));	330	put_queue(vc, 0xe0 \| (c >> 12));
331	put_queue(vc, 0x80 \| ((c >> 6) & 0x3f));	331	put_queue(vc, 0x80 \| ((c >> 6) & 0x3f));
332	put_queue(vc, 0x80 \| (c & 0x3f));	332	put_queue(vc, 0x80 \| (c & 0x3f));
333	} else if (c < 0x110000) {	333	} else if (c < 0x110000) {
334	/* 11110* 10** 10** 10**** */	334	/* 11110* 10** 10** 10**** */
335	put_queue(vc, 0xf0 \| (c >> 18));	335	put_queue(vc, 0xf0 \| (c >> 18));
336	put_queue(vc, 0x80 \| ((c >> 12) & 0x3f));	336	put_queue(vc, 0x80 \| ((c >> 12) & 0x3f));
337	put_queue(vc, 0x80 \| ((c >> 6) & 0x3f));	337	put_queue(vc, 0x80 \| ((c >> 6) & 0x3f));
338	put_queue(vc, 0x80 \| (c & 0x3f));	338	put_queue(vc, 0x80 \| (c & 0x3f));
339	}	339	}
340	}	340	}
341		341
342	/*	342	/*
343	* Called after returning from RAW mode or when changing consoles - recompute	343	* Called after returning from RAW mode or when changing consoles - recompute
344	* shift_down[] and shift_state from key_down[] maybe called when keymap is	344	* shift_down[] and shift_state from key_down[] maybe called when keymap is
345	* undefined, so that shiftkey release is seen	345	* undefined, so that shiftkey release is seen
346	*/	346	*/
347	void compute_shiftstate(void)	347	void compute_shiftstate(void)
348	{	348	{
349	unsigned int i, j, k, sym, val;	349	unsigned int i, j, k, sym, val;
350		350
351	shift_state = 0;	351	shift_state = 0;
352	memset(shift_down, 0, sizeof(shift_down));	352	memset(shift_down, 0, sizeof(shift_down));
353		353
354	for (i = 0; i < ARRAY_SIZE(key_down); i++) {	354	for (i = 0; i < ARRAY_SIZE(key_down); i++) {
355		355
356	if (!key_down[i])	356	if (!key_down[i])
357	continue;	357	continue;
358		358
359	k = i * BITS_PER_LONG;	359	k = i * BITS_PER_LONG;
360		360
361	for (j = 0; j < BITS_PER_LONG; j++, k++) {	361	for (j = 0; j < BITS_PER_LONG; j++, k++) {
362		362
363	if (!test_bit(k, key_down))	363	if (!test_bit(k, key_down))
364	continue;	364	continue;
365		365
366	sym = U(key_maps[0][k]);	366	sym = U(key_maps[0][k]);
367	if (KTYP(sym) != KT_SHIFT && KTYP(sym) != KT_SLOCK)	367	if (KTYP(sym) != KT_SHIFT && KTYP(sym) != KT_SLOCK)
368	continue;	368	continue;
369		369
370	val = KVAL(sym);	370	val = KVAL(sym);
371	if (val == KVAL(K_CAPSSHIFT))	371	if (val == KVAL(K_CAPSSHIFT))
372	val = KVAL(K_SHIFT);	372	val = KVAL(K_SHIFT);
373		373
374	shift_down[val]++;	374	shift_down[val]++;
375	shift_state \|= (1 << val);	375	shift_state \|= (1 << val);
376	}	376	}
377	}	377	}
378	}	378	}
379		379
380	/*	380	/*
381	* We have a combining character DIACR here, followed by the character CH.	381	* We have a combining character DIACR here, followed by the character CH.
382	* If the combination occurs in the table, return the corresponding value.	382	* If the combination occurs in the table, return the corresponding value.
383	* Otherwise, if CH is a space or equals DIACR, return DIACR.	383	* Otherwise, if CH is a space or equals DIACR, return DIACR.
384	* Otherwise, conclude that DIACR was not combining after all,	384	* Otherwise, conclude that DIACR was not combining after all,
385	* queue it and return CH.	385	* queue it and return CH.
386	*/	386	*/
387	static unsigned int handle_diacr(struct vc_data *vc, unsigned int ch)	387	static unsigned int handle_diacr(struct vc_data *vc, unsigned int ch)
388	{	388	{
389	unsigned int d = diacr;	389	unsigned int d = diacr;
390	unsigned int i;	390	unsigned int i;
391		391
392	diacr = 0;	392	diacr = 0;
393		393
394	if ((d & ~0xff) == BRL_UC_ROW) {	394	if ((d & ~0xff) == BRL_UC_ROW) {
395	if ((ch & ~0xff) == BRL_UC_ROW)	395	if ((ch & ~0xff) == BRL_UC_ROW)
396	return d \| ch;	396	return d \| ch;
397	} else {	397	} else {
398	for (i = 0; i < accent_table_size; i++)	398	for (i = 0; i < accent_table_size; i++)
399	if (accent_table[i].diacr == d && accent_table[i].base == ch)	399	if (accent_table[i].diacr == d && accent_table[i].base == ch)
400	return accent_table[i].result;	400	return accent_table[i].result;
401	}	401	}
402		402
403	if (ch == ' ' \|\| ch == (BRL_UC_ROW\|0) \|\| ch == d)	403	if (ch == ' ' \|\| ch == (BRL_UC_ROW\|0) \|\| ch == d)
404	return d;	404	return d;
405		405
406	if (kbd->kbdmode == VC_UNICODE)	406	if (kbd->kbdmode == VC_UNICODE)
407	to_utf8(vc, d);	407	to_utf8(vc, d);
408	else {	408	else {
409	int c = conv_uni_to_8bit(d);	409	int c = conv_uni_to_8bit(d);
410	if (c != -1)	410	if (c != -1)
411	put_queue(vc, c);	411	put_queue(vc, c);
412	}	412	}
413		413
414	return ch;	414	return ch;
415	}	415	}
416		416
417	/*	417	/*
418	* Special function handlers	418	* Special function handlers
419	*/	419	*/
420	static void fn_enter(struct vc_data *vc)	420	static void fn_enter(struct vc_data *vc)
421	{	421	{
422	if (diacr) {	422	if (diacr) {
423	if (kbd->kbdmode == VC_UNICODE)	423	if (kbd->kbdmode == VC_UNICODE)
424	to_utf8(vc, diacr);	424	to_utf8(vc, diacr);
425	else {	425	else {
426	int c = conv_uni_to_8bit(diacr);	426	int c = conv_uni_to_8bit(diacr);
427	if (c != -1)	427	if (c != -1)
428	put_queue(vc, c);	428	put_queue(vc, c);
429	}	429	}
430	diacr = 0;	430	diacr = 0;
431	}	431	}
432	put_queue(vc, 13);	432	put_queue(vc, 13);
433	if (vc_kbd_mode(kbd, VC_CRLF))	433	if (vc_kbd_mode(kbd, VC_CRLF))
434	put_queue(vc, 10);	434	put_queue(vc, 10);
435	}	435	}
436		436
437	static void fn_caps_toggle(struct vc_data *vc)	437	static void fn_caps_toggle(struct vc_data *vc)
438	{	438	{
439	if (rep)	439	if (rep)
440	return;	440	return;
441	chg_vc_kbd_led(kbd, VC_CAPSLOCK);	441	chg_vc_kbd_led(kbd, VC_CAPSLOCK);
442	}	442	}
443		443
444	static void fn_caps_on(struct vc_data *vc)	444	static void fn_caps_on(struct vc_data *vc)
445	{	445	{
446	if (rep)	446	if (rep)
447	return;	447	return;
448	set_vc_kbd_led(kbd, VC_CAPSLOCK);	448	set_vc_kbd_led(kbd, VC_CAPSLOCK);
449	}	449	}
450		450
451	static void fn_show_ptregs(struct vc_data *vc)	451	static void fn_show_ptregs(struct vc_data *vc)
452	{	452	{
453	struct pt_regs *regs = get_irq_regs();	453	struct pt_regs *regs = get_irq_regs();
454	if (regs)	454	if (regs)
455	show_regs(regs);	455	show_regs(regs);
456	}	456	}
457		457
458	static void fn_hold(struct vc_data *vc)	458	static void fn_hold(struct vc_data *vc)
459	{	459	{
460	struct tty_struct *tty = vc->vc_tty;	460	struct tty_struct *tty = vc->vc_tty;
461		461
462	if (rep \|\| !tty)	462	if (rep \|\| !tty)
463	return;	463	return;
464		464
465	/*	465	/*
466	* Note: SCROLLOCK will be set (cleared) by stop_tty (start_tty);	466	* Note: SCROLLOCK will be set (cleared) by stop_tty (start_tty);
467	* these routines are also activated by ^S/^Q.	467	* these routines are also activated by ^S/^Q.
468	* (And SCROLLOCK can also be set by the ioctl KDSKBLED.)	468	* (And SCROLLOCK can also be set by the ioctl KDSKBLED.)
469	*/	469	*/
470	if (tty->stopped)	470	if (tty->stopped)
471	start_tty(tty);	471	start_tty(tty);
472	else	472	else
473	stop_tty(tty);	473	stop_tty(tty);
474	}	474	}
475		475
476	static void fn_num(struct vc_data *vc)	476	static void fn_num(struct vc_data *vc)
477	{	477	{
478	if (vc_kbd_mode(kbd,VC_APPLIC))	478	if (vc_kbd_mode(kbd,VC_APPLIC))
479	applkey(vc, 'P', 1);	479	applkey(vc, 'P', 1);
480	else	480	else
481	fn_bare_num(vc);	481	fn_bare_num(vc);
482	}	482	}
483		483
484	/*	484	/*
485	* Bind this to Shift-NumLock if you work in application keypad mode	485	* Bind this to Shift-NumLock if you work in application keypad mode
486	* but want to be able to change the NumLock flag.	486	* but want to be able to change the NumLock flag.
487	* Bind this to NumLock if you prefer that the NumLock key always	487	* Bind this to NumLock if you prefer that the NumLock key always
488	* changes the NumLock flag.	488	* changes the NumLock flag.
489	*/	489	*/
490	static void fn_bare_num(struct vc_data *vc)	490	static void fn_bare_num(struct vc_data *vc)
491	{	491	{
492	if (!rep)	492	if (!rep)
493	chg_vc_kbd_led(kbd, VC_NUMLOCK);	493	chg_vc_kbd_led(kbd, VC_NUMLOCK);
494	}	494	}
495		495
496	static void fn_lastcons(struct vc_data *vc)	496	static void fn_lastcons(struct vc_data *vc)
497	{	497	{
498	/* switch to the last used console, ChN */	498	/* switch to the last used console, ChN */
499	set_console(last_console);	499	set_console(last_console);
500	}	500	}
501		501
502	static void fn_dec_console(struct vc_data *vc)	502	static void fn_dec_console(struct vc_data *vc)
503	{	503	{
504	int i, cur = fg_console;	504	int i, cur = fg_console;
505		505
506	/* Currently switching? Queue this next switch relative to that. */	506	/* Currently switching? Queue this next switch relative to that. */
507	if (want_console != -1)	507	if (want_console != -1)
508	cur = want_console;	508	cur = want_console;
509		509
510	for (i = cur - 1; i != cur; i--) {	510	for (i = cur - 1; i != cur; i--) {
511	if (i == -1)	511	if (i == -1)
512	i = MAX_NR_CONSOLES - 1;	512	i = MAX_NR_CONSOLES - 1;
513	if (vc_cons_allocated(i))	513	if (vc_cons_allocated(i))
514	break;	514	break;
515	}	515	}
516	set_console(i);	516	set_console(i);
517	}	517	}
518		518
519	static void fn_inc_console(struct vc_data *vc)	519	static void fn_inc_console(struct vc_data *vc)
520	{	520	{
521	int i, cur = fg_console;	521	int i, cur = fg_console;
522		522
523	/* Currently switching? Queue this next switch relative to that. */	523	/* Currently switching? Queue this next switch relative to that. */
524	if (want_console != -1)	524	if (want_console != -1)
525	cur = want_console;	525	cur = want_console;
526		526
527	for (i = cur+1; i != cur; i++) {	527	for (i = cur+1; i != cur; i++) {
528	if (i == MAX_NR_CONSOLES)	528	if (i == MAX_NR_CONSOLES)
529	i = 0;	529	i = 0;
530	if (vc_cons_allocated(i))	530	if (vc_cons_allocated(i))
531	break;	531	break;
532	}	532	}
533	set_console(i);	533	set_console(i);
534	}	534	}
535		535
536	static void fn_send_intr(struct vc_data *vc)	536	static void fn_send_intr(struct vc_data *vc)
537	{	537	{
538	struct tty_struct *tty = vc->vc_tty;	538	struct tty_struct *tty = vc->vc_tty;
539		539
540	if (!tty)	540	if (!tty)
541	return;	541	return;
542	tty_insert_flip_char(tty, 0, TTY_BREAK);	542	tty_insert_flip_char(tty, 0, TTY_BREAK);
543	con_schedule_flip(tty);	543	con_schedule_flip(tty);
544	}	544	}
545		545
546	static void fn_scroll_forw(struct vc_data *vc)	546	static void fn_scroll_forw(struct vc_data *vc)
547	{	547	{
548	scrollfront(vc, 0);	548	scrollfront(vc, 0);
549	}	549	}
550		550
551	static void fn_scroll_back(struct vc_data *vc)	551	static void fn_scroll_back(struct vc_data *vc)
552	{	552	{
553	scrollback(vc, 0);	553	scrollback(vc, 0);
554	}	554	}
555		555
556	static void fn_show_mem(struct vc_data *vc)	556	static void fn_show_mem(struct vc_data *vc)
557	{	557	{
558	show_mem();	558	show_mem();
559	}	559	}
560		560
561	static void fn_show_state(struct vc_data *vc)	561	static void fn_show_state(struct vc_data *vc)
562	{	562	{
563	show_state();	563	show_state();
564	}	564	}
565		565
566	static void fn_boot_it(struct vc_data *vc)	566	static void fn_boot_it(struct vc_data *vc)
567	{	567	{
568	ctrl_alt_del();	568	ctrl_alt_del();
569	}	569	}
570		570
571	static void fn_compose(struct vc_data *vc)	571	static void fn_compose(struct vc_data *vc)
572	{	572	{
573	dead_key_next = 1;	573	dead_key_next = 1;
574	}	574	}
575		575
576	static void fn_spawn_con(struct vc_data *vc)	576	static void fn_spawn_con(struct vc_data *vc)
577	{	577	{
578	spin_lock(&vt_spawn_con.lock);	578	spin_lock(&vt_spawn_con.lock);
579	if (vt_spawn_con.pid)	579	if (vt_spawn_con.pid)
580	if (kill_pid(vt_spawn_con.pid, vt_spawn_con.sig, 1)) {	580	if (kill_pid(vt_spawn_con.pid, vt_spawn_con.sig, 1)) {
581	put_pid(vt_spawn_con.pid);	581	put_pid(vt_spawn_con.pid);
582	vt_spawn_con.pid = NULL;	582	vt_spawn_con.pid = NULL;
583	}	583	}
584	spin_unlock(&vt_spawn_con.lock);	584	spin_unlock(&vt_spawn_con.lock);
585	}	585	}
586		586
587	static void fn_SAK(struct vc_data *vc)	587	static void fn_SAK(struct vc_data *vc)
588	{	588	{
589	struct work_struct *SAK_work = &vc_cons[fg_console].SAK_work;	589	struct work_struct *SAK_work = &vc_cons[fg_console].SAK_work;
590	schedule_work(SAK_work);	590	schedule_work(SAK_work);
591	}	591	}
592		592
593	static void fn_null(struct vc_data *vc)	593	static void fn_null(struct vc_data *vc)
594	{	594	{
595	compute_shiftstate();	595	compute_shiftstate();
596	}	596	}
597		597
598	/*	598	/*
599	* Special key handlers	599	* Special key handlers
600	*/	600	*/
601	static void k_ignore(struct vc_data *vc, unsigned char value, char up_flag)	601	static void k_ignore(struct vc_data *vc, unsigned char value, char up_flag)
602	{	602	{
603	}	603	}
604		604
605	static void k_spec(struct vc_data *vc, unsigned char value, char up_flag)	605	static void k_spec(struct vc_data *vc, unsigned char value, char up_flag)
606	{	606	{
607	if (up_flag)	607	if (up_flag)
608	return;	608	return;
609	if (value >= ARRAY_SIZE(fn_handler))	609	if (value >= ARRAY_SIZE(fn_handler))
610	return;	610	return;
611	if ((kbd->kbdmode == VC_RAW \|\|	611	if ((kbd->kbdmode == VC_RAW \|\|
612	kbd->kbdmode == VC_MEDIUMRAW) &&	612	kbd->kbdmode == VC_MEDIUMRAW) &&
613	value != KVAL(K_SAK))	613	value != KVAL(K_SAK))
614	return; /* SAK is allowed even in raw mode */	614	return; /* SAK is allowed even in raw mode */
615	fn_handler[value](vc);	615	fn_handler[value](vc);
616	}	616	}
617		617
618	static void k_lowercase(struct vc_data *vc, unsigned char value, char up_flag)	618	static void k_lowercase(struct vc_data *vc, unsigned char value, char up_flag)
619	{	619	{
620	printk(KERN_ERR "keyboard.c: k_lowercase was called - impossible\n");	620	printk(KERN_ERR "keyboard.c: k_lowercase was called - impossible\n");
621	}	621	}
622		622
623	static void k_unicode(struct vc_data *vc, unsigned int value, char up_flag)	623	static void k_unicode(struct vc_data *vc, unsigned int value, char up_flag)
624	{	624	{
625	if (up_flag)	625	if (up_flag)
626	return; /* no action, if this is a key release */	626	return; /* no action, if this is a key release */
627		627
628	if (diacr)	628	if (diacr)
629	value = handle_diacr(vc, value);	629	value = handle_diacr(vc, value);
630		630
631	if (dead_key_next) {	631	if (dead_key_next) {
632	dead_key_next = 0;	632	dead_key_next = 0;
633	diacr = value;	633	diacr = value;
634	return;	634	return;
635	}	635	}
636	if (kbd->kbdmode == VC_UNICODE)	636	if (kbd->kbdmode == VC_UNICODE)
637	to_utf8(vc, value);	637	to_utf8(vc, value);
638	else {	638	else {
639	int c = conv_uni_to_8bit(value);	639	int c = conv_uni_to_8bit(value);
640	if (c != -1)	640	if (c != -1)
641	put_queue(vc, c);	641	put_queue(vc, c);
642	}	642	}
643	}	643	}
644		644
645	/*	645	/*
646	* Handle dead key. Note that we now may have several	646	* Handle dead key. Note that we now may have several
647	* dead keys modifying the same character. Very useful	647	* dead keys modifying the same character. Very useful
648	* for Vietnamese.	648	* for Vietnamese.
649	*/	649	*/
650	static void k_deadunicode(struct vc_data *vc, unsigned int value, char up_flag)	650	static void k_deadunicode(struct vc_data *vc, unsigned int value, char up_flag)
651	{	651	{
652	if (up_flag)	652	if (up_flag)
653	return;	653	return;
654	diacr = (diacr ? handle_diacr(vc, value) : value);	654	diacr = (diacr ? handle_diacr(vc, value) : value);
655	}	655	}
656		656
657	static void k_self(struct vc_data *vc, unsigned char value, char up_flag)	657	static void k_self(struct vc_data *vc, unsigned char value, char up_flag)
658	{	658	{
659	unsigned int uni;	659	unsigned int uni;
660	if (kbd->kbdmode == VC_UNICODE)	660	if (kbd->kbdmode == VC_UNICODE)
661	uni = value;	661	uni = value;
662	else	662	else
663	uni = conv_8bit_to_uni(value);	663	uni = conv_8bit_to_uni(value);
664	k_unicode(vc, uni, up_flag);	664	k_unicode(vc, uni, up_flag);
665	}	665	}
666		666
667	static void k_dead2(struct vc_data *vc, unsigned char value, char up_flag)	667	static void k_dead2(struct vc_data *vc, unsigned char value, char up_flag)
668	{	668	{
669	k_deadunicode(vc, value, up_flag);	669	k_deadunicode(vc, value, up_flag);
670	}	670	}
671		671
672	/*	672	/*
673	* Obsolete - for backwards compatibility only	673	* Obsolete - for backwards compatibility only
674	*/	674	*/
675	static void k_dead(struct vc_data *vc, unsigned char value, char up_flag)	675	static void k_dead(struct vc_data *vc, unsigned char value, char up_flag)
676	{	676	{
677	static const unsigned char ret_diacr[NR_DEAD] = {'`', '\'', '^', '~', '"', ',' };	677	static const unsigned char ret_diacr[NR_DEAD] = {'`', '\'', '^', '~', '"', ',' };
678	value = ret_diacr[value];	678	value = ret_diacr[value];
679	k_deadunicode(vc, value, up_flag);	679	k_deadunicode(vc, value, up_flag);
680	}	680	}
681		681
682	static void k_cons(struct vc_data *vc, unsigned char value, char up_flag)	682	static void k_cons(struct vc_data *vc, unsigned char value, char up_flag)
683	{	683	{
684	if (up_flag)	684	if (up_flag)
685	return;	685	return;
686	set_console(value);	686	set_console(value);
687	}	687	}
688		688
689	static void k_fn(struct vc_data *vc, unsigned char value, char up_flag)	689	static void k_fn(struct vc_data *vc, unsigned char value, char up_flag)
690	{	690	{
691	unsigned v;	691	unsigned v;
692		692
693	if (up_flag)	693	if (up_flag)
694	return;	694	return;
695	v = value;	695	v = value;
696	if (v < ARRAY_SIZE(func_table)) {	696	if (v < ARRAY_SIZE(func_table)) {
697	if (func_table[value])	697	if (func_table[value])
698	puts_queue(vc, func_table[value]);	698	puts_queue(vc, func_table[value]);
699	} else	699	} else
700	printk(KERN_ERR "k_fn called with value=%d\n", value);	700	printk(KERN_ERR "k_fn called with value=%d\n", value);
701	}	701	}
702		702
703	static void k_cur(struct vc_data *vc, unsigned char value, char up_flag)	703	static void k_cur(struct vc_data *vc, unsigned char value, char up_flag)
704	{	704	{
705	static const char cur_chars[] = "BDCA";	705	static const char cur_chars[] = "BDCA";
706		706
707	if (up_flag)	707	if (up_flag)
708	return;	708	return;
709	applkey(vc, cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE));	709	applkey(vc, cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE));
710	}	710	}
711		711
712	static void k_pad(struct vc_data *vc, unsigned char value, char up_flag)	712	static void k_pad(struct vc_data *vc, unsigned char value, char up_flag)
713	{	713	{
714	static const char pad_chars[] = "0123456789+-*/\015,.?()#";	714	static const char pad_chars[] = "0123456789+-*/\015,.?()#";
715	static const char app_map[] = "pqrstuvwxylSRQMnnmPQS";	715	static const char app_map[] = "pqrstuvwxylSRQMnnmPQS";
716		716
717	if (up_flag)	717	if (up_flag)
718	return; /* no action, if this is a key release */	718	return; /* no action, if this is a key release */
719		719
720	/* kludge... shift forces cursor/number keys */	720	/* kludge... shift forces cursor/number keys */
721	if (vc_kbd_mode(kbd, VC_APPLIC) && !shift_down[KG_SHIFT]) {	721	if (vc_kbd_mode(kbd, VC_APPLIC) && !shift_down[KG_SHIFT]) {
722	applkey(vc, app_map[value], 1);	722	applkey(vc, app_map[value], 1);
723	return;	723	return;
724	}	724	}
725		725
726	if (!vc_kbd_led(kbd, VC_NUMLOCK))	726	if (!vc_kbd_led(kbd, VC_NUMLOCK))
727	switch (value) {	727	switch (value) {
728	case KVAL(K_PCOMMA):	728	case KVAL(K_PCOMMA):
729	case KVAL(K_PDOT):	729	case KVAL(K_PDOT):
730	k_fn(vc, KVAL(K_REMOVE), 0);	730	k_fn(vc, KVAL(K_REMOVE), 0);
731	return;	731	return;
732	case KVAL(K_P0):	732	case KVAL(K_P0):
733	k_fn(vc, KVAL(K_INSERT), 0);	733	k_fn(vc, KVAL(K_INSERT), 0);
734	return;	734	return;
735	case KVAL(K_P1):	735	case KVAL(K_P1):
736	k_fn(vc, KVAL(K_SELECT), 0);	736	k_fn(vc, KVAL(K_SELECT), 0);
737	return;	737	return;
738	case KVAL(K_P2):	738	case KVAL(K_P2):
739	k_cur(vc, KVAL(K_DOWN), 0);	739	k_cur(vc, KVAL(K_DOWN), 0);
740	return;	740	return;
741	case KVAL(K_P3):	741	case KVAL(K_P3):
742	k_fn(vc, KVAL(K_PGDN), 0);	742	k_fn(vc, KVAL(K_PGDN), 0);
743	return;	743	return;
744	case KVAL(K_P4):	744	case KVAL(K_P4):
745	k_cur(vc, KVAL(K_LEFT), 0);	745	k_cur(vc, KVAL(K_LEFT), 0);
746	return;	746	return;
747	case KVAL(K_P6):	747	case KVAL(K_P6):
748	k_cur(vc, KVAL(K_RIGHT), 0);	748	k_cur(vc, KVAL(K_RIGHT), 0);
749	return;	749	return;
750	case KVAL(K_P7):	750	case KVAL(K_P7):
751	k_fn(vc, KVAL(K_FIND), 0);	751	k_fn(vc, KVAL(K_FIND), 0);
752	return;	752	return;
753	case KVAL(K_P8):	753	case KVAL(K_P8):
754	k_cur(vc, KVAL(K_UP), 0);	754	k_cur(vc, KVAL(K_UP), 0);
755	return;	755	return;
756	case KVAL(K_P9):	756	case KVAL(K_P9):
757	k_fn(vc, KVAL(K_PGUP), 0);	757	k_fn(vc, KVAL(K_PGUP), 0);
758	return;	758	return;
759	case KVAL(K_P5):	759	case KVAL(K_P5):
760	applkey(vc, 'G', vc_kbd_mode(kbd, VC_APPLIC));	760	applkey(vc, 'G', vc_kbd_mode(kbd, VC_APPLIC));
761	return;	761	return;
762	}	762	}
763		763
764	put_queue(vc, pad_chars[value]);	764	put_queue(vc, pad_chars[value]);
765	if (value == KVAL(K_PENTER) && vc_kbd_mode(kbd, VC_CRLF))	765	if (value == KVAL(K_PENTER) && vc_kbd_mode(kbd, VC_CRLF))
766	put_queue(vc, 10);	766	put_queue(vc, 10);
767	}	767	}
768		768
769	static void k_shift(struct vc_data *vc, unsigned char value, char up_flag)	769	static void k_shift(struct vc_data *vc, unsigned char value, char up_flag)
770	{	770	{
771	int old_state = shift_state;	771	int old_state = shift_state;
772		772
773	if (rep)	773	if (rep)
774	return;	774	return;
775	/*	775	/*
776	* Mimic typewriter:	776	* Mimic typewriter:
777	* a CapsShift key acts like Shift but undoes CapsLock	777	* a CapsShift key acts like Shift but undoes CapsLock
778	*/	778	*/
779	if (value == KVAL(K_CAPSSHIFT)) {	779	if (value == KVAL(K_CAPSSHIFT)) {
780	value = KVAL(K_SHIFT);	780	value = KVAL(K_SHIFT);
781	if (!up_flag)	781	if (!up_flag)
782	clr_vc_kbd_led(kbd, VC_CAPSLOCK);	782	clr_vc_kbd_led(kbd, VC_CAPSLOCK);
783	}	783	}
784		784
785	if (up_flag) {	785	if (up_flag) {
786	/*	786	/*
787	* handle the case that two shift or control	787	* handle the case that two shift or control
788	* keys are depressed simultaneously	788	* keys are depressed simultaneously
789	*/	789	*/
790	if (shift_down[value])	790	if (shift_down[value])
791	shift_down[value]--;	791	shift_down[value]--;
792	} else	792	} else
793	shift_down[value]++;	793	shift_down[value]++;
794		794
795	if (shift_down[value])	795	if (shift_down[value])
796	shift_state \|= (1 << value);	796	shift_state \|= (1 << value);
797	else	797	else
798	shift_state &= ~(1 << value);	798	shift_state &= ~(1 << value);
799		799
800	/* kludge */	800	/* kludge */
801	if (up_flag && shift_state != old_state && npadch != -1) {	801	if (up_flag && shift_state != old_state && npadch != -1) {
802	if (kbd->kbdmode == VC_UNICODE)	802	if (kbd->kbdmode == VC_UNICODE)
803	to_utf8(vc, npadch);	803	to_utf8(vc, npadch);
804	else	804	else
805	put_queue(vc, npadch & 0xff);	805	put_queue(vc, npadch & 0xff);
806	npadch = -1;	806	npadch = -1;
807	}	807	}
808	}	808	}
809		809
810	static void k_meta(struct vc_data *vc, unsigned char value, char up_flag)	810	static void k_meta(struct vc_data *vc, unsigned char value, char up_flag)
811	{	811	{
812	if (up_flag)	812	if (up_flag)
813	return;	813	return;
814		814
815	if (vc_kbd_mode(kbd, VC_META)) {	815	if (vc_kbd_mode(kbd, VC_META)) {
816	put_queue(vc, '\033');	816	put_queue(vc, '\033');
817	put_queue(vc, value);	817	put_queue(vc, value);
818	} else	818	} else
819	put_queue(vc, value \| 0x80);	819	put_queue(vc, value \| 0x80);
820	}	820	}
821		821
822	static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag)	822	static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag)
823	{	823	{
824	int base;	824	int base;
825		825
826	if (up_flag)	826	if (up_flag)
827	return;	827	return;
828		828
829	if (value < 10) {	829	if (value < 10) {
830	/* decimal input of code, while Alt depressed */	830	/* decimal input of code, while Alt depressed */
831	base = 10;	831	base = 10;
832	} else {	832	} else {
833	/* hexadecimal input of code, while AltGr depressed */	833	/* hexadecimal input of code, while AltGr depressed */
834	value -= 10;	834	value -= 10;
835	base = 16;	835	base = 16;
836	}	836	}
837		837
838	if (npadch == -1)	838	if (npadch == -1)
839	npadch = value;	839	npadch = value;
840	else	840	else
841	npadch = npadch * base + value;	841	npadch = npadch * base + value;
842	}	842	}
843		843
844	static void k_lock(struct vc_data *vc, unsigned char value, char up_flag)	844	static void k_lock(struct vc_data *vc, unsigned char value, char up_flag)
845	{	845	{
846	if (up_flag \|\| rep)	846	if (up_flag \|\| rep)
847	return;	847	return;
848	chg_vc_kbd_lock(kbd, value);	848	chg_vc_kbd_lock(kbd, value);
849	}	849	}
850		850
851	static void k_slock(struct vc_data *vc, unsigned char value, char up_flag)	851	static void k_slock(struct vc_data *vc, unsigned char value, char up_flag)
852	{	852	{
853	k_shift(vc, value, up_flag);	853	k_shift(vc, value, up_flag);
854	if (up_flag \|\| rep)	854	if (up_flag \|\| rep)
855	return;	855	return;
856	chg_vc_kbd_slock(kbd, value);	856	chg_vc_kbd_slock(kbd, value);
857	/* try to make Alt, oops, AltGr and such work */	857	/* try to make Alt, oops, AltGr and such work */
858	if (!key_maps[kbd->lockstate ^ kbd->slockstate]) {	858	if (!key_maps[kbd->lockstate ^ kbd->slockstate]) {
859	kbd->slockstate = 0;	859	kbd->slockstate = 0;
860	chg_vc_kbd_slock(kbd, value);	860	chg_vc_kbd_slock(kbd, value);
861	}	861	}
862	}	862	}
863		863
864	/* by default, 300ms interval for combination release */	864	/* by default, 300ms interval for combination release */
865	static unsigned brl_timeout = 300;	865	static unsigned brl_timeout = 300;
866	MODULE_PARM_DESC(brl_timeout, "Braille keys release delay in ms (0 for commit on first key release)");	866	MODULE_PARM_DESC(brl_timeout, "Braille keys release delay in ms (0 for commit on first key release)");
867	module_param(brl_timeout, uint, 0644);	867	module_param(brl_timeout, uint, 0644);
868		868
869	static unsigned brl_nbchords = 1;	869	static unsigned brl_nbchords = 1;
870	MODULE_PARM_DESC(brl_nbchords, "Number of chords that produce a braille pattern (0 for dead chords)");	870	MODULE_PARM_DESC(brl_nbchords, "Number of chords that produce a braille pattern (0 for dead chords)");
871	module_param(brl_nbchords, uint, 0644);	871	module_param(brl_nbchords, uint, 0644);
872		872
873	static void k_brlcommit(struct vc_data *vc, unsigned int pattern, char up_flag)	873	static void k_brlcommit(struct vc_data *vc, unsigned int pattern, char up_flag)
874	{	874	{
875	static unsigned long chords;	875	static unsigned long chords;
876	static unsigned committed;	876	static unsigned committed;
877		877
878	if (!brl_nbchords)	878	if (!brl_nbchords)
879	k_deadunicode(vc, BRL_UC_ROW \| pattern, up_flag);	879	k_deadunicode(vc, BRL_UC_ROW \| pattern, up_flag);
880	else {	880	else {
881	committed \|= pattern;	881	committed \|= pattern;
882	chords++;	882	chords++;
883	if (chords == brl_nbchords) {	883	if (chords == brl_nbchords) {
884	k_unicode(vc, BRL_UC_ROW \| committed, up_flag);	884	k_unicode(vc, BRL_UC_ROW \| committed, up_flag);
885	chords = 0;	885	chords = 0;
886	committed = 0;	886	committed = 0;
887	}	887	}
888	}	888	}
889	}	889	}
890		890
891	static void k_brl(struct vc_data *vc, unsigned char value, char up_flag)	891	static void k_brl(struct vc_data *vc, unsigned char value, char up_flag)
892	{	892	{
893	static unsigned pressed,committing;	893	static unsigned pressed,committing;
894	static unsigned long releasestart;	894	static unsigned long releasestart;
895		895
896	if (kbd->kbdmode != VC_UNICODE) {	896	if (kbd->kbdmode != VC_UNICODE) {
897	if (!up_flag)	897	if (!up_flag)
898	printk("keyboard mode must be unicode for braille patterns\n");	898	printk("keyboard mode must be unicode for braille patterns\n");
899	return;	899	return;
900	}	900	}
901		901
902	if (!value) {	902	if (!value) {
903	k_unicode(vc, BRL_UC_ROW, up_flag);	903	k_unicode(vc, BRL_UC_ROW, up_flag);
904	return;	904	return;
905	}	905	}
906		906
907	if (value > 8)	907	if (value > 8)
908	return;	908	return;
909		909
910	if (up_flag) {	910	if (up_flag) {
911	if (brl_timeout) {	911	if (brl_timeout) {
912	if (!committing \|\|	912	if (!committing \|\|
913	jiffies - releasestart > (brl_timeout * HZ) / 1000) {	913	jiffies - releasestart > (brl_timeout * HZ) / 1000) {
914	committing = pressed;	914	committing = pressed;
915	releasestart = jiffies;	915	releasestart = jiffies;
916	}	916	}
917	pressed &= ~(1 << (value - 1));	917	pressed &= ~(1 << (value - 1));
918	if (!pressed) {	918	if (!pressed) {
919	if (committing) {	919	if (committing) {
920	k_brlcommit(vc, committing, 0);	920	k_brlcommit(vc, committing, 0);
921	committing = 0;	921	committing = 0;
922	}	922	}
923	}	923	}
924	} else {	924	} else {
925	if (committing) {	925	if (committing) {
926	k_brlcommit(vc, committing, 0);	926	k_brlcommit(vc, committing, 0);
927	committing = 0;	927	committing = 0;
928	}	928	}
929	pressed &= ~(1 << (value - 1));	929	pressed &= ~(1 << (value - 1));
930	}	930	}
931	} else {	931	} else {
932	pressed \|= 1 << (value - 1);	932	pressed \|= 1 << (value - 1);
933	if (!brl_timeout)	933	if (!brl_timeout)
934	committing = pressed;	934	committing = pressed;
935	}	935	}
936	}	936	}
937		937
938	/*	938	/*
939	* The leds display either (i) the status of NumLock, CapsLock, ScrollLock,	939	* The leds display either (i) the status of NumLock, CapsLock, ScrollLock,
940	* or (ii) whatever pattern of lights people want to show using KDSETLED,	940	* or (ii) whatever pattern of lights people want to show using KDSETLED,
941	* or (iii) specified bits of specified words in kernel memory.	941	* or (iii) specified bits of specified words in kernel memory.
942	*/	942	*/
943	unsigned char getledstate(void)	943	unsigned char getledstate(void)
944	{	944	{
945	return ledstate;	945	return ledstate;
946	}	946	}
947		947
948	void setledstate(struct kbd_struct *kbd, unsigned int led)	948	void setledstate(struct kbd_struct *kbd, unsigned int led)
949	{	949	{
950	if (!(led & ~7)) {	950	if (!(led & ~7)) {
951	ledioctl = led;	951	ledioctl = led;
952	kbd->ledmode = LED_SHOW_IOCTL;	952	kbd->ledmode = LED_SHOW_IOCTL;
953	} else	953	} else
954	kbd->ledmode = LED_SHOW_FLAGS;	954	kbd->ledmode = LED_SHOW_FLAGS;
955	set_leds();	955	set_leds();
956	}	956	}
957		957
958	static inline unsigned char getleds(void)	958	static inline unsigned char getleds(void)
959	{	959	{
960	struct kbd_struct *kbd = kbd_table + fg_console;	960	struct kbd_struct *kbd = kbd_table + fg_console;
961	unsigned char leds;	961	unsigned char leds;
962	int i;	962	int i;
963		963
964	if (kbd->ledmode == LED_SHOW_IOCTL)	964	if (kbd->ledmode == LED_SHOW_IOCTL)
965	return ledioctl;	965	return ledioctl;
966		966
967	leds = kbd->ledflagstate;	967	leds = kbd->ledflagstate;
968		968
969	if (kbd->ledmode == LED_SHOW_MEM) {	969	if (kbd->ledmode == LED_SHOW_MEM) {
970	for (i = 0; i < 3; i++)	970	for (i = 0; i < 3; i++)
971	if (ledptrs[i].valid) {	971	if (ledptrs[i].valid) {
972	if (*ledptrs[i].addr & ledptrs[i].mask)	972	if (*ledptrs[i].addr & ledptrs[i].mask)
973	leds \|= (1 << i);	973	leds \|= (1 << i);
974	else	974	else
975	leds &= ~(1 << i);	975	leds &= ~(1 << i);
976	}	976	}
977	}	977	}
978	return leds;	978	return leds;
979	}	979	}
980		980
981	/*	981	/*
982	* This routine is the bottom half of the keyboard interrupt	982	* This routine is the bottom half of the keyboard interrupt
983	* routine, and runs with all interrupts enabled. It does	983	* routine, and runs with all interrupts enabled. It does
984	* console changing, led setting and copy_to_cooked, which can	984	* console changing, led setting and copy_to_cooked, which can
985	* take a reasonably long time.	985	* take a reasonably long time.
986	*	986	*
987	* Aside from timing (which isn't really that important for	987	* Aside from timing (which isn't really that important for
988	* keyboard interrupts as they happen often), using the software	988	* keyboard interrupts as they happen often), using the software
989	* interrupt routines for this thing allows us to easily mask	989	* interrupt routines for this thing allows us to easily mask
990	* this when we don't want any of the above to happen.	990	* this when we don't want any of the above to happen.
991	* This allows for easy and efficient race-condition prevention	991	* This allows for easy and efficient race-condition prevention
992	* for kbd_start => input_inject_event(dev, EV_LED, ...) => ...	992	* for kbd_start => input_inject_event(dev, EV_LED, ...) => ...
993	*/	993	*/
994		994
995	static void kbd_bh(unsigned long dummy)	995	static void kbd_bh(unsigned long dummy)
996	{	996	{
997	struct list_head *node;	997	struct list_head *node;
998	unsigned char leds = getleds();	998	unsigned char leds = getleds();
999		999
1000	if (leds != ledstate) {	1000	if (leds != ledstate) {
1001	list_for_each(node, &kbd_handler.h_list) {	1001	list_for_each(node, &kbd_handler.h_list) {
1002	struct input_handle *handle = to_handle_h(node);	1002	struct input_handle *handle = to_handle_h(node);
1003	input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));	1003	input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1004	input_inject_event(handle, EV_LED, LED_NUML, !!(leds & 0x02));	1004	input_inject_event(handle, EV_LED, LED_NUML, !!(leds & 0x02));
1005	input_inject_event(handle, EV_LED, LED_CAPSL, !!(leds & 0x04));	1005	input_inject_event(handle, EV_LED, LED_CAPSL, !!(leds & 0x04));
1006	input_inject_event(handle, EV_SYN, SYN_REPORT, 0);	1006	input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
1007	}	1007	}
1008	}	1008	}
1009		1009
1010	ledstate = leds;	1010	ledstate = leds;
1011	}	1011	}
1012		1012
1013	DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);	1013	DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);
1014		1014
1015	#if defined(CONFIG_X86) \|\| defined(CONFIG_IA64) \|\| defined(CONFIG_ALPHA) \|\|\	1015	#if defined(CONFIG_X86) \|\| defined(CONFIG_IA64) \|\| defined(CONFIG_ALPHA) \|\|\
1016	defined(CONFIG_MIPS) \|\| defined(CONFIG_PPC) \|\| defined(CONFIG_SPARC) \|\|\	1016	defined(CONFIG_MIPS) \|\| defined(CONFIG_PPC) \|\| defined(CONFIG_SPARC) \|\|\
1017	defined(CONFIG_PARISC) \|\| defined(CONFIG_SUPERH) \|\|\	1017	defined(CONFIG_PARISC) \|\| defined(CONFIG_SUPERH) \|\|\
1018	(defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC))	1018	(defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC))
1019		1019
1020	#define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\	1020	#define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\
1021	((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001))	1021	((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001))
1022		1022
1023	static const unsigned short x86_keycodes[256] =	1023	static const unsigned short x86_keycodes[256] =
1024	{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,	1024	{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
1025	16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,	1025	16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1026	32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,	1026	32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1027	48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,	1027	48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1028	64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,	1028	64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1029	80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,	1029	80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
1030	284,285,309, 0,312, 91,327,328,329,331,333,335,336,337,338,339,	1030	284,285,309, 0,312, 91,327,328,329,331,333,335,336,337,338,339,
1031	367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,	1031	367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
1032	360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,	1032	360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
1033	103,104,105,275,287,279,258,106,274,107,294,364,358,363,362,361,	1033	103,104,105,275,287,279,258,106,274,107,294,364,358,363,362,361,
1034	291,108,381,281,290,272,292,305,280, 99,112,257,306,359,113,114,	1034	291,108,381,281,290,272,292,305,280, 99,112,257,306,359,113,114,
1035	264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,	1035	264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
1036	377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,	1036	377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
1037	308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,	1037	308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
1038	332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };	1038	332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
1039		1039
1040	#ifdef CONFIG_SPARC	1040	#ifdef CONFIG_SPARC
1041	static int sparc_l1_a_state = 0;	1041	static int sparc_l1_a_state = 0;
1042	extern void sun_do_break(void);	1042	extern void sun_do_break(void);
1043	#endif	1043	#endif
1044		1044
1045	static int emulate_raw(struct vc_data *vc, unsigned int keycode,	1045	static int emulate_raw(struct vc_data *vc, unsigned int keycode,
1046	unsigned char up_flag)	1046	unsigned char up_flag)
1047	{	1047	{
1048	int code;	1048	int code;
1049		1049
1050	switch (keycode) {	1050	switch (keycode) {
1051	case KEY_PAUSE:	1051	case KEY_PAUSE:
1052	put_queue(vc, 0xe1);	1052	put_queue(vc, 0xe1);
1053	put_queue(vc, 0x1d \| up_flag);	1053	put_queue(vc, 0x1d \| up_flag);
1054	put_queue(vc, 0x45 \| up_flag);	1054	put_queue(vc, 0x45 \| up_flag);
1055	break;	1055	break;
1056		1056
1057	case KEY_HANGEUL:	1057	case KEY_HANGEUL:
1058	if (!up_flag)	1058	if (!up_flag)
1059	put_queue(vc, 0xf2);	1059	put_queue(vc, 0xf2);
1060	break;	1060	break;
1061		1061
1062	case KEY_HANJA:	1062	case KEY_HANJA:
1063	if (!up_flag)	1063	if (!up_flag)
1064	put_queue(vc, 0xf1);	1064	put_queue(vc, 0xf1);
1065	break;	1065	break;
1066		1066
1067	case KEY_SYSRQ:	1067	case KEY_SYSRQ:
1068	/*	1068	/*
1069	* Real AT keyboards (that's what we're trying	1069	* Real AT keyboards (that's what we're trying
1070	* to emulate here emit 0xe0 0x2a 0xe0 0x37 when	1070	* to emulate here emit 0xe0 0x2a 0xe0 0x37 when
1071	* pressing PrtSc/SysRq alone, but simply 0x54	1071	* pressing PrtSc/SysRq alone, but simply 0x54
1072	* when pressing Alt+PrtSc/SysRq.	1072	* when pressing Alt+PrtSc/SysRq.
1073	*/	1073	*/
1074	if (sysrq_alt) {	1074	if (sysrq_alt) {
1075	put_queue(vc, 0x54 \| up_flag);	1075	put_queue(vc, 0x54 \| up_flag);
1076	} else {	1076	} else {
1077	put_queue(vc, 0xe0);	1077	put_queue(vc, 0xe0);
1078	put_queue(vc, 0x2a \| up_flag);	1078	put_queue(vc, 0x2a \| up_flag);
1079	put_queue(vc, 0xe0);	1079	put_queue(vc, 0xe0);
1080	put_queue(vc, 0x37 \| up_flag);	1080	put_queue(vc, 0x37 \| up_flag);
1081	}	1081	}
1082	break;	1082	break;
1083		1083
1084	default:	1084	default:
1085	if (keycode > 255)	1085	if (keycode > 255)
1086	return -1;	1086	return -1;
1087		1087
1088	code = x86_keycodes[keycode];	1088	code = x86_keycodes[keycode];
1089	if (!code)	1089	if (!code)
1090	return -1;	1090	return -1;
1091		1091
1092	if (code & 0x100)	1092	if (code & 0x100)
1093	put_queue(vc, 0xe0);	1093	put_queue(vc, 0xe0);
1094	put_queue(vc, (code & 0x7f) \| up_flag);	1094	put_queue(vc, (code & 0x7f) \| up_flag);
1095		1095
1096	break;	1096	break;
1097	}	1097	}
1098		1098
1099	return 0;	1099	return 0;
1100	}	1100	}
1101		1101
1102	#else	1102	#else
1103		1103
1104	#define HW_RAW(dev) 0	1104	#define HW_RAW(dev) 0
1105		1105
1106	#warning "Cannot generate rawmode keyboard for your architecture yet."	1106	#warning "Cannot generate rawmode keyboard for your architecture yet."
1107		1107
1108	static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)	1108	static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
1109	{	1109	{
1110	if (keycode > 127)	1110	if (keycode > 127)
1111	return -1;	1111	return -1;
1112		1112
1113	put_queue(vc, keycode \| up_flag);	1113	put_queue(vc, keycode \| up_flag);
1114	return 0;	1114	return 0;
1115	}	1115	}
1116	#endif	1116	#endif
1117		1117
1118	static void kbd_rawcode(unsigned char data)	1118	static void kbd_rawcode(unsigned char data)
1119	{	1119	{
1120	struct vc_data *vc = vc_cons[fg_console].d;	1120	struct vc_data *vc = vc_cons[fg_console].d;
1121	kbd = kbd_table + fg_console;	1121	kbd = kbd_table + fg_console;
1122	if (kbd->kbdmode == VC_RAW)	1122	if (kbd->kbdmode == VC_RAW)
1123	put_queue(vc, data);	1123	put_queue(vc, data);
1124	}	1124	}
1125		1125
1126	static void kbd_keycode(unsigned int keycode, int down, int hw_raw)	1126	static void kbd_keycode(unsigned int keycode, int down, int hw_raw)
1127	{	1127	{
1128	struct vc_data *vc = vc_cons[fg_console].d;	1128	struct vc_data *vc = vc_cons[fg_console].d;
1129	unsigned short keysym, *key_map;	1129	unsigned short keysym, *key_map;
1130	unsigned char type, raw_mode;	1130	unsigned char type, raw_mode;
1131	struct tty_struct *tty;	1131	struct tty_struct *tty;
1132	int shift_final;	1132	int shift_final;
1133		1133
1134	tty = vc->vc_tty;	1134	tty = vc->vc_tty;
1135		1135
1136	if (tty && (!tty->driver_data)) {	1136	if (tty && (!tty->driver_data)) {
1137	/* No driver data? Strange. Okay we fix it then. */	1137	/* No driver data? Strange. Okay we fix it then. */
1138	tty->driver_data = vc;	1138	tty->driver_data = vc;
1139	}	1139	}
1140		1140
1141	kbd = kbd_table + fg_console;	1141	kbd = kbd_table + fg_console;
1142		1142
1143	if (keycode == KEY_LEFTALT \|\| keycode == KEY_RIGHTALT)	1143	if (keycode == KEY_LEFTALT \|\| keycode == KEY_RIGHTALT)
1144	sysrq_alt = down ? keycode : 0;	1144	sysrq_alt = down ? keycode : 0;
1145	#ifdef CONFIG_SPARC	1145	#ifdef CONFIG_SPARC
1146	if (keycode == KEY_STOP)	1146	if (keycode == KEY_STOP)
1147	sparc_l1_a_state = down;	1147	sparc_l1_a_state = down;
1148	#endif	1148	#endif
1149		1149
1150	rep = (down == 2);	1150	rep = (down == 2);
1151		1151
1152	#ifdef CONFIG_MAC_EMUMOUSEBTN	1152	#ifdef CONFIG_MAC_EMUMOUSEBTN
1153	if (mac_hid_mouse_emulate_buttons(1, keycode, down))	1153	if (mac_hid_mouse_emulate_buttons(1, keycode, down))
1154	return;	1154	return;
1155	#endif /* CONFIG_MAC_EMUMOUSEBTN */	1155	#endif /* CONFIG_MAC_EMUMOUSEBTN */
1156		1156
1157	if ((raw_mode = (kbd->kbdmode == VC_RAW)) && !hw_raw)	1157	if ((raw_mode = (kbd->kbdmode == VC_RAW)) && !hw_raw)
1158	if (emulate_raw(vc, keycode, !down << 7))	1158	if (emulate_raw(vc, keycode, !down << 7))
1159	if (keycode < BTN_MISC && printk_ratelimit())	1159	if (keycode < BTN_MISC && printk_ratelimit())
1160	printk(KERN_WARNING "keyboard.c: can't emulate rawmode for keycode %d\n", keycode);	1160	printk(KERN_WARNING "keyboard.c: can't emulate rawmode for keycode %d\n", keycode);
1161		1161
1162	#ifdef CONFIG_MAGIC_SYSRQ /* Handle the SysRq Hack */	1162	#ifdef CONFIG_MAGIC_SYSRQ /* Handle the SysRq Hack */
1163	if (keycode == KEY_SYSRQ && (sysrq_down \|\| (down == 1 && sysrq_alt))) {	1163	if (keycode == KEY_SYSRQ && (sysrq_down \|\| (down == 1 && sysrq_alt))) {
1164	if (!sysrq_down) {	1164	if (!sysrq_down) {
1165	sysrq_down = down;	1165	sysrq_down = down;
1166	sysrq_alt_use = sysrq_alt;	1166	sysrq_alt_use = sysrq_alt;
1167	}	1167	}
1168	return;	1168	return;
1169	}	1169	}
1170	if (sysrq_down && !down && keycode == sysrq_alt_use)	1170	if (sysrq_down && !down && keycode == sysrq_alt_use)
1171	sysrq_down = 0;	1171	sysrq_down = 0;
1172	if (sysrq_down && down && !rep) {	1172	if (sysrq_down && down && !rep) {
1173	handle_sysrq(kbd_sysrq_xlate[keycode], tty);	1173	handle_sysrq(kbd_sysrq_xlate[keycode], tty);
1174	return;	1174	return;
1175	}	1175	}
1176	#endif	1176	#endif
1177	#ifdef CONFIG_SPARC	1177	#ifdef CONFIG_SPARC
1178	if (keycode == KEY_A && sparc_l1_a_state) {	1178	if (keycode == KEY_A && sparc_l1_a_state) {
1179	sparc_l1_a_state = 0;	1179	sparc_l1_a_state = 0;
1180	sun_do_break();	1180	sun_do_break();
1181	}	1181	}
1182	#endif	1182	#endif
1183		1183
1184	if (kbd->kbdmode == VC_MEDIUMRAW) {	1184	if (kbd->kbdmode == VC_MEDIUMRAW) {
1185	/*	1185	/*
1186	* This is extended medium raw mode, with keys above 127	1186	* This is extended medium raw mode, with keys above 127
1187	* encoded as 0, high 7 bits, low 7 bits, with the 0 bearing	1187	* encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
1188	* the 'up' flag if needed. 0 is reserved, so this shouldn't	1188	* the 'up' flag if needed. 0 is reserved, so this shouldn't
1189	* interfere with anything else. The two bytes after 0 will	1189	* interfere with anything else. The two bytes after 0 will
1190	* always have the up flag set not to interfere with older	1190	* always have the up flag set not to interfere with older
1191	* applications. This allows for 16384 different keycodes,	1191	* applications. This allows for 16384 different keycodes,
1192	* which should be enough.	1192	* which should be enough.
1193	*/	1193	*/
1194	if (keycode < 128) {	1194	if (keycode < 128) {
1195	put_queue(vc, keycode \| (!down << 7));	1195	put_queue(vc, keycode \| (!down << 7));
1196	} else {	1196	} else {
1197	put_queue(vc, !down << 7);	1197	put_queue(vc, !down << 7);
1198	put_queue(vc, (keycode >> 7) \| 0x80);	1198	put_queue(vc, (keycode >> 7) \| 0x80);
1199	put_queue(vc, keycode \| 0x80);	1199	put_queue(vc, keycode \| 0x80);
1200	}	1200	}
1201	raw_mode = 1;	1201	raw_mode = 1;
1202	}	1202	}
1203		1203
1204	if (down)	1204	if (down)
1205	set_bit(keycode, key_down);	1205	set_bit(keycode, key_down);
1206	else	1206	else
1207	clear_bit(keycode, key_down);	1207	clear_bit(keycode, key_down);
1208		1208
1209	if (rep &&	1209	if (rep &&
1210	(!vc_kbd_mode(kbd, VC_REPEAT) \|\|	1210	(!vc_kbd_mode(kbd, VC_REPEAT) \|\|
1211	(tty && !L_ECHO(tty) && tty->driver->chars_in_buffer(tty)))) {	1211	(tty && !L_ECHO(tty) && tty->driver->chars_in_buffer(tty)))) {
1212	/*	1212	/*
1213	* Don't repeat a key if the input buffers are not empty and the	1213	* Don't repeat a key if the input buffers are not empty and the
1214	* characters get aren't echoed locally. This makes key repeat	1214	* characters get aren't echoed locally. This makes key repeat
1215	* usable with slow applications and under heavy loads.	1215	* usable with slow applications and under heavy loads.
1216	*/	1216	*/
1217	return;	1217	return;
1218	}	1218	}
1219		1219
1220	shift_final = (shift_state \| kbd->slockstate) ^ kbd->lockstate;	1220	shift_final = (shift_state \| kbd->slockstate) ^ kbd->lockstate;
1221	key_map = key_maps[shift_final];	1221	key_map = key_maps[shift_final];
1222		1222
1223	if (!key_map) {	1223	if (!key_map) {
1224	compute_shiftstate();	1224	compute_shiftstate();
1225	kbd->slockstate = 0;	1225	kbd->slockstate = 0;
1226	return;	1226	return;
1227	}	1227	}
1228		1228
1229	if (keycode > NR_KEYS)	1229	if (keycode > NR_KEYS)
1230	if (keycode >= KEY_BRL_DOT1 && keycode <= KEY_BRL_DOT8)	1230	if (keycode >= KEY_BRL_DOT1 && keycode <= KEY_BRL_DOT8)
1231	keysym = K(KT_BRL, keycode - KEY_BRL_DOT1 + 1);	1231	keysym = K(KT_BRL, keycode - KEY_BRL_DOT1 + 1);
1232	else	1232	else
1233	return;	1233	return;
1234	else	1234	else
1235	keysym = key_map[keycode];	1235	keysym = key_map[keycode];
1236		1236
1237	type = KTYP(keysym);	1237	type = KTYP(keysym);
1238		1238
1239	if (type < 0xf0) {	1239	if (type < 0xf0) {
1240	if (down && !raw_mode)	1240	if (down && !raw_mode)
1241	to_utf8(vc, keysym);	1241	to_utf8(vc, keysym);
1242	return;	1242	return;
1243	}	1243	}
1244		1244
1245	type -= 0xf0;	1245	type -= 0xf0;
1246		1246
1247	if (raw_mode && type != KT_SPEC && type != KT_SHIFT)	1247	if (raw_mode && type != KT_SPEC && type != KT_SHIFT)
1248	return;	1248	return;
1249		1249
1250	if (type == KT_LETTER) {	1250	if (type == KT_LETTER) {
1251	type = KT_LATIN;	1251	type = KT_LATIN;
1252	if (vc_kbd_led(kbd, VC_CAPSLOCK)) {	1252	if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
1253	key_map = key_maps[shift_final ^ (1 << KG_SHIFT)];	1253	key_map = key_maps[shift_final ^ (1 << KG_SHIFT)];
1254	if (key_map)	1254	if (key_map)
1255	keysym = key_map[keycode];	1255	keysym = key_map[keycode];
1256	}	1256	}
1257	}	1257	}
1258		1258
1259	(*k_handler[type])(vc, keysym & 0xff, !down);	1259	(*k_handler[type])(vc, keysym & 0xff, !down);
1260		1260
1261	if (type != KT_SLOCK)	1261	if (type != KT_SLOCK)
1262	kbd->slockstate = 0;	1262	kbd->slockstate = 0;
1263	}	1263	}
1264		1264
1265	static void kbd_event(struct input_handle *handle, unsigned int event_type,	1265	static void kbd_event(struct input_handle *handle, unsigned int event_type,
1266	unsigned int event_code, int value)	1266	unsigned int event_code, int value)
1267	{	1267	{
1268	if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev))	1268	if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev))
1269	kbd_rawcode(value);	1269	kbd_rawcode(value);
1270	if (event_type == EV_KEY)	1270	if (event_type == EV_KEY)
1271	kbd_keycode(event_code, value, HW_RAW(handle->dev));	1271	kbd_keycode(event_code, value, HW_RAW(handle->dev));
1272	tasklet_schedule(&keyboard_tasklet);	1272	tasklet_schedule(&keyboard_tasklet);
1273	do_poke_blanked_console = 1;	1273	do_poke_blanked_console = 1;
1274	schedule_console_callback();	1274	schedule_console_callback();
1275	}	1275	}
1276		1276
1277	/*	1277	/*
1278	* When a keyboard (or other input device) is found, the kbd_connect	1278	* When a keyboard (or other input device) is found, the kbd_connect
1279	* function is called. The function then looks at the device, and if it	1279	* function is called. The function then looks at the device, and if it
1280	* likes it, it can open it and get events from it. In this (kbd_connect)	1280	* likes it, it can open it and get events from it. In this (kbd_connect)
1281	* function, we should decide which VT to bind that keyboard to initially.	1281	* function, we should decide which VT to bind that keyboard to initially.
1282	*/	1282	*/
1283	static int kbd_connect(struct input_handler handler, struct input_dev dev,	1283	static int kbd_connect(struct input_handler handler, struct input_dev dev,
1284	const struct input_device_id *id)	1284	const struct input_device_id *id)
1285	{	1285	{
1286	struct input_handle *handle;	1286	struct input_handle *handle;
1287	int error;	1287	int error;
1288	int i;	1288	int i;
1289		1289
1290	for (i = KEY_RESERVED; i < BTN_MISC; i++)	1290	for (i = KEY_RESERVED; i < BTN_MISC; i++)
1291	if (test_bit(i, dev->keybit))	1291	if (test_bit(i, dev->keybit))
1292	break;	1292	break;
1293		1293
1294	if (i == BTN_MISC && !test_bit(EV_SND, dev->evbit))	1294	if (i == BTN_MISC && !test_bit(EV_SND, dev->evbit))
1295	return -ENODEV;	1295	return -ENODEV;
1296		1296
1297	handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);	1297	handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
1298	if (!handle)	1298	if (!handle)
1299	return -ENOMEM;	1299	return -ENOMEM;
1300		1300
1301	handle->dev = dev;	1301	handle->dev = dev;
1302	handle->handler = handler;	1302	handle->handler = handler;
1303	handle->name = "kbd";	1303	handle->name = "kbd";
1304		1304
1305	error = input_register_handle(handle);	1305	error = input_register_handle(handle);
1306	if (error)	1306	if (error)
1307	goto err_free_handle;	1307	goto err_free_handle;
1308		1308
1309	error = input_open_device(handle);	1309	error = input_open_device(handle);
1310	if (error)	1310	if (error)
1311	goto err_unregister_handle;	1311	goto err_unregister_handle;
1312		1312
1313	return 0;	1313	return 0;
1314		1314
1315	err_unregister_handle:	1315	err_unregister_handle:
1316	input_unregister_handle(handle);	1316	input_unregister_handle(handle);
1317	err_free_handle:	1317	err_free_handle:
1318	kfree(handle);	1318	kfree(handle);
1319	return error;	1319	return error;
1320	}	1320	}
1321		1321
1322	static void kbd_disconnect(struct input_handle *handle)	1322	static void kbd_disconnect(struct input_handle *handle)
1323	{	1323	{
1324	input_close_device(handle);	1324	input_close_device(handle);
1325	input_unregister_handle(handle);	1325	input_unregister_handle(handle);
1326	kfree(handle);	1326	kfree(handle);
1327	}	1327	}
1328		1328
1329	/*	1329	/*
1330	* Start keyboard handler on the new keyboard by refreshing LED state to	1330	* Start keyboard handler on the new keyboard by refreshing LED state to
1331	* match the rest of the system.	1331	* match the rest of the system.
1332	*/	1332	*/
1333	static void kbd_start(struct input_handle *handle)	1333	static void kbd_start(struct input_handle *handle)
1334	{	1334	{
1335	unsigned char leds = ledstate;	1335	unsigned char leds = ledstate;
1336		1336
1337	tasklet_disable(&keyboard_tasklet);	1337	tasklet_disable(&keyboard_tasklet);
1338	if (leds != 0xff) {	1338	if (leds != 0xff) {
1339	input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));	1339	input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1340	input_inject_event(handle, EV_LED, LED_NUML, !!(leds & 0x02));	1340	input_inject_event(handle, EV_LED, LED_NUML, !!(leds & 0x02));
1341	input_inject_event(handle, EV_LED, LED_CAPSL, !!(leds & 0x04));	1341	input_inject_event(handle, EV_LED, LED_CAPSL, !!(leds & 0x04));
1342	input_inject_event(handle, EV_SYN, SYN_REPORT, 0);	1342	input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
1343	}	1343	}
1344	tasklet_enable(&keyboard_tasklet);	1344	tasklet_enable(&keyboard_tasklet);
1345	}	1345	}
1346		1346
1347	static const struct input_device_id kbd_ids[] = {	1347	static const struct input_device_id kbd_ids[] = {
1348	{	1348	{
1349	.flags = INPUT_DEVICE_ID_MATCH_EVBIT,	1349	.flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1350	.evbit = { BIT(EV_KEY) },	1350	.evbit = { BIT(EV_KEY) },
1351	},	1351	},
1352		1352
1353	{	1353	{
1354	.flags = INPUT_DEVICE_ID_MATCH_EVBIT,	1354	.flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1355	.evbit = { BIT(EV_SND) },	1355	.evbit = { BIT(EV_SND) },
1356	},	1356	},
1357		1357
1358	{ }, /* Terminating entry */	1358	{ }, /* Terminating entry */
1359	};	1359	};
1360		1360
1361	MODULE_DEVICE_TABLE(input, kbd_ids);	1361	MODULE_DEVICE_TABLE(input, kbd_ids);
1362		1362
1363	static struct input_handler kbd_handler = {	1363	static struct input_handler kbd_handler = {
1364	.event = kbd_event,	1364	.event = kbd_event,
1365	.connect = kbd_connect,	1365	.connect = kbd_connect,
1366	.disconnect = kbd_disconnect,	1366	.disconnect = kbd_disconnect,
1367	.start = kbd_start,	1367	.start = kbd_start,
1368	.name = "kbd",	1368	.name = "kbd",
1369	.id_table = kbd_ids,	1369	.id_table = kbd_ids,
1370	};	1370	};
1371		1371
1372	int __init kbd_init(void)	1372	int __init kbd_init(void)
1373	{	1373	{
1374	int i;	1374	int i;
1375	int error;	1375	int error;
1376		1376
1377	for (i = 0; i < MAX_NR_CONSOLES; i++) {	1377	for (i = 0; i < MAX_NR_CONSOLES; i++) {
1378	kbd_table[i].ledflagstate = KBD_DEFLEDS;	1378	kbd_table[i].ledflagstate = KBD_DEFLEDS;
1379	kbd_table[i].default_ledflagstate = KBD_DEFLEDS;	1379	kbd_table[i].default_ledflagstate = KBD_DEFLEDS;
1380	kbd_table[i].ledmode = LED_SHOW_FLAGS;	1380	kbd_table[i].ledmode = LED_SHOW_FLAGS;
1381	kbd_table[i].lockstate = KBD_DEFLOCK;	1381	kbd_table[i].lockstate = KBD_DEFLOCK;
1382	kbd_table[i].slockstate = 0;	1382	kbd_table[i].slockstate = 0;
1383	kbd_table[i].modeflags = KBD_DEFMODE;	1383	kbd_table[i].modeflags = KBD_DEFMODE;
1384	kbd_table[i].kbdmode = VC_XLATE;	1384	kbd_table[i].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
1385	}	1385	}
1386		1386
1387	error = input_register_handler(&kbd_handler);	1387	error = input_register_handler(&kbd_handler);
1388	if (error)	1388	if (error)
1389	return error;	1389	return error;
1390		1390
1391	tasklet_enable(&keyboard_tasklet);	1391	tasklet_enable(&keyboard_tasklet);
1392	tasklet_schedule(&keyboard_tasklet);	1392	tasklet_schedule(&keyboard_tasklet);
1393		1393
1394	return 0;	1394	return 0;
1395	}	1395	}
1396		1396

drivers/char/sysrq.c

Diff comments View file @ 2e8ecb9

1	/* -- linux-c --	1	/* -- linux-c --
2	*	2	*
3	* $Id: sysrq.c,v 1.15 1998/08/23 14:56:41 mj Exp $	3	* $Id: sysrq.c,v 1.15 1998/08/23 14:56:41 mj Exp $
4	*	4	*
5	* Linux Magic System Request Key Hacks	5	* Linux Magic System Request Key Hacks
6	*	6	*
7	* (c) 1997 Martin Mares <mj@atrey.karlin.mff.cuni.cz>	7	* (c) 1997 Martin Mares <mj@atrey.karlin.mff.cuni.cz>
8	* based on ideas by Pavel Machek <pavel@atrey.karlin.mff.cuni.cz>	8	* based on ideas by Pavel Machek <pavel@atrey.karlin.mff.cuni.cz>
9	*	9	*
10	* (c) 2000 Crutcher Dunnavant <crutcher+kernel@datastacks.com>	10	* (c) 2000 Crutcher Dunnavant <crutcher+kernel@datastacks.com>
11	* overhauled to use key registration	11	* overhauled to use key registration
12	* based upon discusions in irc://irc.openprojects.net/#kernelnewbies	12	* based upon discusions in irc://irc.openprojects.net/#kernelnewbies
13	*/	13	*/
14		14
15	#include <linux/sched.h>	15	#include <linux/sched.h>
16	#include <linux/interrupt.h>	16	#include <linux/interrupt.h>
17	#include <linux/mm.h>	17	#include <linux/mm.h>
18	#include <linux/fs.h>	18	#include <linux/fs.h>
19	#include <linux/tty.h>	19	#include <linux/tty.h>
20	#include <linux/mount.h>	20	#include <linux/mount.h>
21	#include <linux/kdev_t.h>	21	#include <linux/kdev_t.h>
22	#include <linux/major.h>	22	#include <linux/major.h>
23	#include <linux/reboot.h>	23	#include <linux/reboot.h>
24	#include <linux/sysrq.h>	24	#include <linux/sysrq.h>
25	#include <linux/kbd_kern.h>	25	#include <linux/kbd_kern.h>
26	#include <linux/quotaops.h>	26	#include <linux/quotaops.h>
27	#include <linux/kernel.h>	27	#include <linux/kernel.h>
28	#include <linux/module.h>	28	#include <linux/module.h>
29	#include <linux/suspend.h>	29	#include <linux/suspend.h>
30	#include <linux/writeback.h>	30	#include <linux/writeback.h>
31	#include <linux/buffer_head.h> /* for fsync_bdev() */	31	#include <linux/buffer_head.h> /* for fsync_bdev() */
32	#include <linux/swap.h>	32	#include <linux/swap.h>
33	#include <linux/spinlock.h>	33	#include <linux/spinlock.h>
34	#include <linux/vt_kern.h>	34	#include <linux/vt_kern.h>
35	#include <linux/workqueue.h>	35	#include <linux/workqueue.h>
36	#include <linux/kexec.h>	36	#include <linux/kexec.h>
37	#include <linux/irq.h>	37	#include <linux/irq.h>
38	#include <linux/hrtimer.h>	38	#include <linux/hrtimer.h>
39	#include <linux/oom.h>	39	#include <linux/oom.h>
40		40
41	#include <asm/ptrace.h>	41	#include <asm/ptrace.h>
42	#include <asm/irq_regs.h>	42	#include <asm/irq_regs.h>
43		43
44	/* Whether we react on sysrq keys or just ignore them */	44	/* Whether we react on sysrq keys or just ignore them */
45	int __read_mostly __sysrq_enabled = 1;	45	int __read_mostly __sysrq_enabled = 1;
46		46
47	static int __read_mostly sysrq_always_enabled;	47	static int __read_mostly sysrq_always_enabled;
48		48
49	int sysrq_on(void)	49	int sysrq_on(void)
50	{	50	{
51	return __sysrq_enabled \|\| sysrq_always_enabled;	51	return __sysrq_enabled \|\| sysrq_always_enabled;
52	}	52	}
53		53
54	/*	54	/*
55	* A value of 1 means 'all', other nonzero values are an op mask:	55	* A value of 1 means 'all', other nonzero values are an op mask:
56	*/	56	*/
57	static inline int sysrq_on_mask(int mask)	57	static inline int sysrq_on_mask(int mask)
58	{	58	{
59	return sysrq_always_enabled \|\| __sysrq_enabled == 1 \|\|	59	return sysrq_always_enabled \|\| __sysrq_enabled == 1 \|\|
60	(__sysrq_enabled & mask);	60	(__sysrq_enabled & mask);
61	}	61	}
62		62
63	static int __init sysrq_always_enabled_setup(char *str)	63	static int __init sysrq_always_enabled_setup(char *str)
64	{	64	{
65	sysrq_always_enabled = 1;	65	sysrq_always_enabled = 1;
66	printk(KERN_INFO "debug: sysrq always enabled.\n");	66	printk(KERN_INFO "debug: sysrq always enabled.\n");
67		67
68	return 1;	68	return 1;
69	}	69	}
70		70
71	__setup("sysrq_always_enabled", sysrq_always_enabled_setup);	71	__setup("sysrq_always_enabled", sysrq_always_enabled_setup);
72		72
73		73
74	static void sysrq_handle_loglevel(int key, struct tty_struct *tty)	74	static void sysrq_handle_loglevel(int key, struct tty_struct *tty)
75	{	75	{
76	int i;	76	int i;
77	i = key - '0';	77	i = key - '0';
78	console_loglevel = 7;	78	console_loglevel = 7;
79	printk("Loglevel set to %d\n", i);	79	printk("Loglevel set to %d\n", i);
80	console_loglevel = i;	80	console_loglevel = i;
81	}	81	}
82	static struct sysrq_key_op sysrq_loglevel_op = {	82	static struct sysrq_key_op sysrq_loglevel_op = {
83	.handler = sysrq_handle_loglevel,	83	.handler = sysrq_handle_loglevel,
84	.help_msg = "loglevel0-8",	84	.help_msg = "loglevel0-8",
85	.action_msg = "Changing Loglevel",	85	.action_msg = "Changing Loglevel",
86	.enable_mask = SYSRQ_ENABLE_LOG,	86	.enable_mask = SYSRQ_ENABLE_LOG,
87	};	87	};
88		88
89	#ifdef CONFIG_VT	89	#ifdef CONFIG_VT
90	static void sysrq_handle_SAK(int key, struct tty_struct *tty)	90	static void sysrq_handle_SAK(int key, struct tty_struct *tty)
91	{	91	{
92	struct work_struct *SAK_work = &vc_cons[fg_console].SAK_work;	92	struct work_struct *SAK_work = &vc_cons[fg_console].SAK_work;
93	schedule_work(SAK_work);	93	schedule_work(SAK_work);
94	}	94	}
95	static struct sysrq_key_op sysrq_SAK_op = {	95	static struct sysrq_key_op sysrq_SAK_op = {
96	.handler = sysrq_handle_SAK,	96	.handler = sysrq_handle_SAK,
97	.help_msg = "saK",	97	.help_msg = "saK",
98	.action_msg = "SAK",	98	.action_msg = "SAK",
99	.enable_mask = SYSRQ_ENABLE_KEYBOARD,	99	.enable_mask = SYSRQ_ENABLE_KEYBOARD,
100	};	100	};
101	#else	101	#else
102	#define sysrq_SAK_op ((struct sysrq_key_op )0)	102	#define sysrq_SAK_op ((struct sysrq_key_op )0)
103	#endif	103	#endif
104		104
105	#ifdef CONFIG_VT	105	#ifdef CONFIG_VT
106	static void sysrq_handle_unraw(int key, struct tty_struct *tty)	106	static void sysrq_handle_unraw(int key, struct tty_struct *tty)
107	{	107	{
108	struct kbd_struct *kbd = &kbd_table[fg_console];	108	struct kbd_struct *kbd = &kbd_table[fg_console];
109		109
110	if (kbd)	110	if (kbd)
111	kbd->kbdmode = VC_XLATE;	111	kbd->kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
112	}	112	}
113	static struct sysrq_key_op sysrq_unraw_op = {	113	static struct sysrq_key_op sysrq_unraw_op = {
114	.handler = sysrq_handle_unraw,	114	.handler = sysrq_handle_unraw,
115	.help_msg = "unRaw",	115	.help_msg = "unRaw",
116	.action_msg = "Keyboard mode set to XLATE",	116	.action_msg = "Keyboard mode set to system default",
117	.enable_mask = SYSRQ_ENABLE_KEYBOARD,	117	.enable_mask = SYSRQ_ENABLE_KEYBOARD,
118	};	118	};
119	#else	119	#else
120	#define sysrq_unraw_op ((struct sysrq_key_op )0)	120	#define sysrq_unraw_op ((struct sysrq_key_op )0)
121	#endif /* CONFIG_VT */	121	#endif /* CONFIG_VT */
122		122
123	#ifdef CONFIG_KEXEC	123	#ifdef CONFIG_KEXEC
124	static void sysrq_handle_crashdump(int key, struct tty_struct *tty)	124	static void sysrq_handle_crashdump(int key, struct tty_struct *tty)
125	{	125	{
126	crash_kexec(get_irq_regs());	126	crash_kexec(get_irq_regs());
127	}	127	}
128	static struct sysrq_key_op sysrq_crashdump_op = {	128	static struct sysrq_key_op sysrq_crashdump_op = {
129	.handler = sysrq_handle_crashdump,	129	.handler = sysrq_handle_crashdump,
130	.help_msg = "Crashdump",	130	.help_msg = "Crashdump",
131	.action_msg = "Trigger a crashdump",	131	.action_msg = "Trigger a crashdump",
132	.enable_mask = SYSRQ_ENABLE_DUMP,	132	.enable_mask = SYSRQ_ENABLE_DUMP,
133	};	133	};
134	#else	134	#else
135	#define sysrq_crashdump_op ((struct sysrq_key_op )0)	135	#define sysrq_crashdump_op ((struct sysrq_key_op )0)
136	#endif	136	#endif
137		137
138	static void sysrq_handle_reboot(int key, struct tty_struct *tty)	138	static void sysrq_handle_reboot(int key, struct tty_struct *tty)
139	{	139	{
140	lockdep_off();	140	lockdep_off();
141	local_irq_enable();	141	local_irq_enable();
142	emergency_restart();	142	emergency_restart();
143	}	143	}
144	static struct sysrq_key_op sysrq_reboot_op = {	144	static struct sysrq_key_op sysrq_reboot_op = {
145	.handler = sysrq_handle_reboot,	145	.handler = sysrq_handle_reboot,
146	.help_msg = "reBoot",	146	.help_msg = "reBoot",
147	.action_msg = "Resetting",	147	.action_msg = "Resetting",
148	.enable_mask = SYSRQ_ENABLE_BOOT,	148	.enable_mask = SYSRQ_ENABLE_BOOT,
149	};	149	};
150		150
151	static void sysrq_handle_sync(int key, struct tty_struct *tty)	151	static void sysrq_handle_sync(int key, struct tty_struct *tty)
152	{	152	{
153	emergency_sync();	153	emergency_sync();
154	}	154	}
155	static struct sysrq_key_op sysrq_sync_op = {	155	static struct sysrq_key_op sysrq_sync_op = {
156	.handler = sysrq_handle_sync,	156	.handler = sysrq_handle_sync,
157	.help_msg = "Sync",	157	.help_msg = "Sync",
158	.action_msg = "Emergency Sync",	158	.action_msg = "Emergency Sync",
159	.enable_mask = SYSRQ_ENABLE_SYNC,	159	.enable_mask = SYSRQ_ENABLE_SYNC,
160	};	160	};
161		161
162	static void sysrq_handle_show_timers(int key, struct tty_struct *tty)	162	static void sysrq_handle_show_timers(int key, struct tty_struct *tty)
163	{	163	{
164	sysrq_timer_list_show();	164	sysrq_timer_list_show();
165	}	165	}
166		166
167	static struct sysrq_key_op sysrq_show_timers_op = {	167	static struct sysrq_key_op sysrq_show_timers_op = {
168	.handler = sysrq_handle_show_timers,	168	.handler = sysrq_handle_show_timers,
169	.help_msg = "show-all-timers(Q)",	169	.help_msg = "show-all-timers(Q)",
170	.action_msg = "Show Pending Timers",	170	.action_msg = "Show Pending Timers",
171	};	171	};
172		172
173	static void sysrq_handle_mountro(int key, struct tty_struct *tty)	173	static void sysrq_handle_mountro(int key, struct tty_struct *tty)
174	{	174	{
175	emergency_remount();	175	emergency_remount();
176	}	176	}
177	static struct sysrq_key_op sysrq_mountro_op = {	177	static struct sysrq_key_op sysrq_mountro_op = {
178	.handler = sysrq_handle_mountro,	178	.handler = sysrq_handle_mountro,
179	.help_msg = "Unmount",	179	.help_msg = "Unmount",
180	.action_msg = "Emergency Remount R/O",	180	.action_msg = "Emergency Remount R/O",
181	.enable_mask = SYSRQ_ENABLE_REMOUNT,	181	.enable_mask = SYSRQ_ENABLE_REMOUNT,
182	};	182	};
183		183
184	#ifdef CONFIG_LOCKDEP	184	#ifdef CONFIG_LOCKDEP
185	static void sysrq_handle_showlocks(int key, struct tty_struct *tty)	185	static void sysrq_handle_showlocks(int key, struct tty_struct *tty)
186	{	186	{
187	debug_show_all_locks();	187	debug_show_all_locks();
188	}	188	}
189		189
190	static struct sysrq_key_op sysrq_showlocks_op = {	190	static struct sysrq_key_op sysrq_showlocks_op = {
191	.handler = sysrq_handle_showlocks,	191	.handler = sysrq_handle_showlocks,
192	.help_msg = "show-all-locks(D)",	192	.help_msg = "show-all-locks(D)",
193	.action_msg = "Show Locks Held",	193	.action_msg = "Show Locks Held",
194	};	194	};
195	#else	195	#else
196	#define sysrq_showlocks_op ((struct sysrq_key_op )0)	196	#define sysrq_showlocks_op ((struct sysrq_key_op )0)
197	#endif	197	#endif
198		198
199	static void sysrq_handle_showregs(int key, struct tty_struct *tty)	199	static void sysrq_handle_showregs(int key, struct tty_struct *tty)
200	{	200	{
201	struct pt_regs *regs = get_irq_regs();	201	struct pt_regs *regs = get_irq_regs();
202	if (regs)	202	if (regs)
203	show_regs(regs);	203	show_regs(regs);
204	}	204	}
205	static struct sysrq_key_op sysrq_showregs_op = {	205	static struct sysrq_key_op sysrq_showregs_op = {
206	.handler = sysrq_handle_showregs,	206	.handler = sysrq_handle_showregs,
207	.help_msg = "showPc",	207	.help_msg = "showPc",
208	.action_msg = "Show Regs",	208	.action_msg = "Show Regs",
209	.enable_mask = SYSRQ_ENABLE_DUMP,	209	.enable_mask = SYSRQ_ENABLE_DUMP,
210	};	210	};
211		211
212	static void sysrq_handle_showstate(int key, struct tty_struct *tty)	212	static void sysrq_handle_showstate(int key, struct tty_struct *tty)
213	{	213	{
214	show_state();	214	show_state();
215	}	215	}
216	static struct sysrq_key_op sysrq_showstate_op = {	216	static struct sysrq_key_op sysrq_showstate_op = {
217	.handler = sysrq_handle_showstate,	217	.handler = sysrq_handle_showstate,
218	.help_msg = "showTasks",	218	.help_msg = "showTasks",
219	.action_msg = "Show State",	219	.action_msg = "Show State",
220	.enable_mask = SYSRQ_ENABLE_DUMP,	220	.enable_mask = SYSRQ_ENABLE_DUMP,
221	};	221	};
222		222
223	static void sysrq_handle_showstate_blocked(int key, struct tty_struct *tty)	223	static void sysrq_handle_showstate_blocked(int key, struct tty_struct *tty)
224	{	224	{
225	show_state_filter(TASK_UNINTERRUPTIBLE);	225	show_state_filter(TASK_UNINTERRUPTIBLE);
226	}	226	}
227	static struct sysrq_key_op sysrq_showstate_blocked_op = {	227	static struct sysrq_key_op sysrq_showstate_blocked_op = {
228	.handler = sysrq_handle_showstate_blocked,	228	.handler = sysrq_handle_showstate_blocked,
229	.help_msg = "shoW-blocked-tasks",	229	.help_msg = "shoW-blocked-tasks",
230	.action_msg = "Show Blocked State",	230	.action_msg = "Show Blocked State",
231	.enable_mask = SYSRQ_ENABLE_DUMP,	231	.enable_mask = SYSRQ_ENABLE_DUMP,
232	};	232	};
233		233
234		234
235	static void sysrq_handle_showmem(int key, struct tty_struct *tty)	235	static void sysrq_handle_showmem(int key, struct tty_struct *tty)
236	{	236	{
237	show_mem();	237	show_mem();
238	}	238	}
239	static struct sysrq_key_op sysrq_showmem_op = {	239	static struct sysrq_key_op sysrq_showmem_op = {
240	.handler = sysrq_handle_showmem,	240	.handler = sysrq_handle_showmem,
241	.help_msg = "showMem",	241	.help_msg = "showMem",
242	.action_msg = "Show Memory",	242	.action_msg = "Show Memory",
243	.enable_mask = SYSRQ_ENABLE_DUMP,	243	.enable_mask = SYSRQ_ENABLE_DUMP,
244	};	244	};
245		245
246	/*	246	/*
247	* Signal sysrq helper function. Sends a signal to all user processes.	247	* Signal sysrq helper function. Sends a signal to all user processes.
248	*/	248	*/
249	static void send_sig_all(int sig)	249	static void send_sig_all(int sig)
250	{	250	{
251	struct task_struct *p;	251	struct task_struct *p;
252		252
253	for_each_process(p) {	253	for_each_process(p) {
254	if (p->mm && !is_init(p))	254	if (p->mm && !is_init(p))
255	/* Not swapper, init nor kernel thread */	255	/* Not swapper, init nor kernel thread */
256	force_sig(sig, p);	256	force_sig(sig, p);
257	}	257	}
258	}	258	}
259		259
260	static void sysrq_handle_term(int key, struct tty_struct *tty)	260	static void sysrq_handle_term(int key, struct tty_struct *tty)
261	{	261	{
262	send_sig_all(SIGTERM);	262	send_sig_all(SIGTERM);
263	console_loglevel = 8;	263	console_loglevel = 8;
264	}	264	}
265	static struct sysrq_key_op sysrq_term_op = {	265	static struct sysrq_key_op sysrq_term_op = {
266	.handler = sysrq_handle_term,	266	.handler = sysrq_handle_term,
267	.help_msg = "tErm",	267	.help_msg = "tErm",
268	.action_msg = "Terminate All Tasks",	268	.action_msg = "Terminate All Tasks",
269	.enable_mask = SYSRQ_ENABLE_SIGNAL,	269	.enable_mask = SYSRQ_ENABLE_SIGNAL,
270	};	270	};
271		271
272	static void moom_callback(struct work_struct *ignored)	272	static void moom_callback(struct work_struct *ignored)
273	{	273	{
274	out_of_memory(&NODE_DATA(0)->node_zonelists[ZONE_NORMAL],	274	out_of_memory(&NODE_DATA(0)->node_zonelists[ZONE_NORMAL],
275	GFP_KERNEL, 0);	275	GFP_KERNEL, 0);
276	}	276	}
277		277
278	static DECLARE_WORK(moom_work, moom_callback);	278	static DECLARE_WORK(moom_work, moom_callback);
279		279
280	static void sysrq_handle_moom(int key, struct tty_struct *tty)	280	static void sysrq_handle_moom(int key, struct tty_struct *tty)
281	{	281	{
282	schedule_work(&moom_work);	282	schedule_work(&moom_work);
283	}	283	}
284	static struct sysrq_key_op sysrq_moom_op = {	284	static struct sysrq_key_op sysrq_moom_op = {
285	.handler = sysrq_handle_moom,	285	.handler = sysrq_handle_moom,
286	.help_msg = "Full",	286	.help_msg = "Full",
287	.action_msg = "Manual OOM execution",	287	.action_msg = "Manual OOM execution",
288	};	288	};
289		289
290	static void sysrq_handle_kill(int key, struct tty_struct *tty)	290	static void sysrq_handle_kill(int key, struct tty_struct *tty)
291	{	291	{
292	send_sig_all(SIGKILL);	292	send_sig_all(SIGKILL);
293	console_loglevel = 8;	293	console_loglevel = 8;
294	}	294	}
295	static struct sysrq_key_op sysrq_kill_op = {	295	static struct sysrq_key_op sysrq_kill_op = {
296	.handler = sysrq_handle_kill,	296	.handler = sysrq_handle_kill,
297	.help_msg = "kIll",	297	.help_msg = "kIll",
298	.action_msg = "Kill All Tasks",	298	.action_msg = "Kill All Tasks",
299	.enable_mask = SYSRQ_ENABLE_SIGNAL,	299	.enable_mask = SYSRQ_ENABLE_SIGNAL,
300	};	300	};
301		301
302	static void sysrq_handle_unrt(int key, struct tty_struct *tty)	302	static void sysrq_handle_unrt(int key, struct tty_struct *tty)
303	{	303	{
304	normalize_rt_tasks();	304	normalize_rt_tasks();
305	}	305	}
306	static struct sysrq_key_op sysrq_unrt_op = {	306	static struct sysrq_key_op sysrq_unrt_op = {
307	.handler = sysrq_handle_unrt,	307	.handler = sysrq_handle_unrt,
308	.help_msg = "Nice",	308	.help_msg = "Nice",
309	.action_msg = "Nice All RT Tasks",	309	.action_msg = "Nice All RT Tasks",
310	.enable_mask = SYSRQ_ENABLE_RTNICE,	310	.enable_mask = SYSRQ_ENABLE_RTNICE,
311	};	311	};
312		312
313	/* Key Operations table and lock */	313	/* Key Operations table and lock */
314	static DEFINE_SPINLOCK(sysrq_key_table_lock);	314	static DEFINE_SPINLOCK(sysrq_key_table_lock);
315		315
316	static struct sysrq_key_op *sysrq_key_table[36] = {	316	static struct sysrq_key_op *sysrq_key_table[36] = {
317	&sysrq_loglevel_op, /* 0 */	317	&sysrq_loglevel_op, /* 0 */
318	&sysrq_loglevel_op, /* 1 */	318	&sysrq_loglevel_op, /* 1 */
319	&sysrq_loglevel_op, /* 2 */	319	&sysrq_loglevel_op, /* 2 */
320	&sysrq_loglevel_op, /* 3 */	320	&sysrq_loglevel_op, /* 3 */
321	&sysrq_loglevel_op, /* 4 */	321	&sysrq_loglevel_op, /* 4 */
322	&sysrq_loglevel_op, /* 5 */	322	&sysrq_loglevel_op, /* 5 */
323	&sysrq_loglevel_op, /* 6 */	323	&sysrq_loglevel_op, /* 6 */
324	&sysrq_loglevel_op, /* 7 */	324	&sysrq_loglevel_op, /* 7 */
325	&sysrq_loglevel_op, /* 8 */	325	&sysrq_loglevel_op, /* 8 */
326	&sysrq_loglevel_op, /* 9 */	326	&sysrq_loglevel_op, /* 9 */
327		327
328	/*	328	/*
329	* a: Don't use for system provided sysrqs, it is handled specially on	329	* a: Don't use for system provided sysrqs, it is handled specially on
330	* sparc and will never arrive.	330	* sparc and will never arrive.
331	*/	331	*/
332	NULL, /* a */	332	NULL, /* a */
333	&sysrq_reboot_op, /* b */	333	&sysrq_reboot_op, /* b */
334	&sysrq_crashdump_op, /* c & ibm_emac driver debug */	334	&sysrq_crashdump_op, /* c & ibm_emac driver debug */
335	&sysrq_showlocks_op, /* d */	335	&sysrq_showlocks_op, /* d */
336	&sysrq_term_op, /* e */	336	&sysrq_term_op, /* e */
337	&sysrq_moom_op, /* f */	337	&sysrq_moom_op, /* f */
338	/* g: May be registered by ppc for kgdb */	338	/* g: May be registered by ppc for kgdb */
339	NULL, /* g */	339	NULL, /* g */
340	NULL, /* h */	340	NULL, /* h */
341	&sysrq_kill_op, /* i */	341	&sysrq_kill_op, /* i */
342	NULL, /* j */	342	NULL, /* j */
343	&sysrq_SAK_op, /* k */	343	&sysrq_SAK_op, /* k */
344	NULL, /* l */	344	NULL, /* l */
345	&sysrq_showmem_op, /* m */	345	&sysrq_showmem_op, /* m */
346	&sysrq_unrt_op, /* n */	346	&sysrq_unrt_op, /* n */
347	/* o: This will often be registered as 'Off' at init time */	347	/* o: This will often be registered as 'Off' at init time */
348	NULL, /* o */	348	NULL, /* o */
349	&sysrq_showregs_op, /* p */	349	&sysrq_showregs_op, /* p */
350	&sysrq_show_timers_op, /* q */	350	&sysrq_show_timers_op, /* q */
351	&sysrq_unraw_op, /* r */	351	&sysrq_unraw_op, /* r */
352	&sysrq_sync_op, /* s */	352	&sysrq_sync_op, /* s */
353	&sysrq_showstate_op, /* t */	353	&sysrq_showstate_op, /* t */
354	&sysrq_mountro_op, /* u */	354	&sysrq_mountro_op, /* u */
355	/* v: May be registered at init time by SMP VOYAGER */	355	/* v: May be registered at init time by SMP VOYAGER */
356	NULL, /* v */	356	NULL, /* v */
357	&sysrq_showstate_blocked_op, /* w */	357	&sysrq_showstate_blocked_op, /* w */
358	/* x: May be registered on ppc/powerpc for xmon */	358	/* x: May be registered on ppc/powerpc for xmon */
359	NULL, /* x */	359	NULL, /* x */
360	NULL, /* y */	360	NULL, /* y */
361	NULL /* z */	361	NULL /* z */
362	};	362	};
363		363
364	/* key2index calculation, -1 on invalid index */	364	/* key2index calculation, -1 on invalid index */
365	static int sysrq_key_table_key2index(int key)	365	static int sysrq_key_table_key2index(int key)
366	{	366	{
367	int retval;	367	int retval;
368		368
369	if ((key >= '0') && (key <= '9'))	369	if ((key >= '0') && (key <= '9'))
370	retval = key - '0';	370	retval = key - '0';
371	else if ((key >= 'a') && (key <= 'z'))	371	else if ((key >= 'a') && (key <= 'z'))
372	retval = key + 10 - 'a';	372	retval = key + 10 - 'a';
373	else	373	else
374	retval = -1;	374	retval = -1;
375	return retval;	375	return retval;
376	}	376	}
377		377
378	/*	378	/*
379	* get and put functions for the table, exposed to modules.	379	* get and put functions for the table, exposed to modules.
380	*/	380	*/
381	struct sysrq_key_op *__sysrq_get_key_op(int key)	381	struct sysrq_key_op *__sysrq_get_key_op(int key)
382	{	382	{
383	struct sysrq_key_op *op_p = NULL;	383	struct sysrq_key_op *op_p = NULL;
384	int i;	384	int i;
385		385
386	i = sysrq_key_table_key2index(key);	386	i = sysrq_key_table_key2index(key);
387	if (i != -1)	387	if (i != -1)
388	op_p = sysrq_key_table[i];	388	op_p = sysrq_key_table[i];
389	return op_p;	389	return op_p;
390	}	390	}
391		391
392	static void __sysrq_put_key_op(int key, struct sysrq_key_op *op_p)	392	static void __sysrq_put_key_op(int key, struct sysrq_key_op *op_p)
393	{	393	{
394	int i = sysrq_key_table_key2index(key);	394	int i = sysrq_key_table_key2index(key);
395		395
396	if (i != -1)	396	if (i != -1)
397	sysrq_key_table[i] = op_p;	397	sysrq_key_table[i] = op_p;
398	}	398	}
399		399
400	/*	400	/*
401	* This is the non-locking version of handle_sysrq. It must/can only be called	401	* This is the non-locking version of handle_sysrq. It must/can only be called
402	* by sysrq key handlers, as they are inside of the lock	402	* by sysrq key handlers, as they are inside of the lock
403	*/	403	*/
404	void __handle_sysrq(int key, struct tty_struct *tty, int check_mask)	404	void __handle_sysrq(int key, struct tty_struct *tty, int check_mask)
405	{	405	{
406	struct sysrq_key_op *op_p;	406	struct sysrq_key_op *op_p;
407	int orig_log_level;	407	int orig_log_level;
408	int i;	408	int i;
409	unsigned long flags;	409	unsigned long flags;
410		410
411	spin_lock_irqsave(&sysrq_key_table_lock, flags);	411	spin_lock_irqsave(&sysrq_key_table_lock, flags);
412	orig_log_level = console_loglevel;	412	orig_log_level = console_loglevel;
413	console_loglevel = 7;	413	console_loglevel = 7;
414	printk(KERN_INFO "SysRq : ");	414	printk(KERN_INFO "SysRq : ");
415		415
416	op_p = __sysrq_get_key_op(key);	416	op_p = __sysrq_get_key_op(key);
417	if (op_p) {	417	if (op_p) {
418	/*	418	/*
419	* Should we check for enabled operations (/proc/sysrq-trigger	419	* Should we check for enabled operations (/proc/sysrq-trigger
420	* should not) and is the invoked operation enabled?	420	* should not) and is the invoked operation enabled?
421	*/	421	*/
422	if (!check_mask \|\| sysrq_on_mask(op_p->enable_mask)) {	422	if (!check_mask \|\| sysrq_on_mask(op_p->enable_mask)) {
423	printk("%s\n", op_p->action_msg);	423	printk("%s\n", op_p->action_msg);
424	console_loglevel = orig_log_level;	424	console_loglevel = orig_log_level;
425	op_p->handler(key, tty);	425	op_p->handler(key, tty);
426	} else {	426	} else {
427	printk("This sysrq operation is disabled.\n");	427	printk("This sysrq operation is disabled.\n");
428	}	428	}
429	} else {	429	} else {
430	printk("HELP : ");	430	printk("HELP : ");
431	/* Only print the help msg once per handler */	431	/* Only print the help msg once per handler */
432	for (i = 0; i < ARRAY_SIZE(sysrq_key_table); i++) {	432	for (i = 0; i < ARRAY_SIZE(sysrq_key_table); i++) {
433	if (sysrq_key_table[i]) {	433	if (sysrq_key_table[i]) {
434	int j;	434	int j;
435		435
436	for (j = 0; sysrq_key_table[i] !=	436	for (j = 0; sysrq_key_table[i] !=
437	sysrq_key_table[j]; j++)	437	sysrq_key_table[j]; j++)
438	;	438	;
439	if (j != i)	439	if (j != i)
440	continue;	440	continue;
441	printk("%s ", sysrq_key_table[i]->help_msg);	441	printk("%s ", sysrq_key_table[i]->help_msg);
442	}	442	}
443	}	443	}
444	printk("\n");	444	printk("\n");
445	console_loglevel = orig_log_level;	445	console_loglevel = orig_log_level;
446	}	446	}
447	spin_unlock_irqrestore(&sysrq_key_table_lock, flags);	447	spin_unlock_irqrestore(&sysrq_key_table_lock, flags);
448	}	448	}
449		449
450	/*	450	/*
451	* This function is called by the keyboard handler when SysRq is pressed	451	* This function is called by the keyboard handler when SysRq is pressed
452	* and any other keycode arrives.	452	* and any other keycode arrives.
453	*/	453	*/
454	void handle_sysrq(int key, struct tty_struct *tty)	454	void handle_sysrq(int key, struct tty_struct *tty)
455	{	455	{
456	if (sysrq_on())	456	if (sysrq_on())
457	__handle_sysrq(key, tty, 1);	457	__handle_sysrq(key, tty, 1);
458	}	458	}
459	EXPORT_SYMBOL(handle_sysrq);	459	EXPORT_SYMBOL(handle_sysrq);
460		460
461	static int __sysrq_swap_key_ops(int key, struct sysrq_key_op *insert_op_p,	461	static int __sysrq_swap_key_ops(int key, struct sysrq_key_op *insert_op_p,
462	struct sysrq_key_op *remove_op_p)	462	struct sysrq_key_op *remove_op_p)
463	{	463	{
464		464
465	int retval;	465	int retval;
466	unsigned long flags;	466	unsigned long flags;
467		467
468	spin_lock_irqsave(&sysrq_key_table_lock, flags);	468	spin_lock_irqsave(&sysrq_key_table_lock, flags);
469	if (__sysrq_get_key_op(key) == remove_op_p) {	469	if (__sysrq_get_key_op(key) == remove_op_p) {
470	__sysrq_put_key_op(key, insert_op_p);	470	__sysrq_put_key_op(key, insert_op_p);
471	retval = 0;	471	retval = 0;
472	} else {	472	} else {
473	retval = -1;	473	retval = -1;
474	}	474	}
475	spin_unlock_irqrestore(&sysrq_key_table_lock, flags);	475	spin_unlock_irqrestore(&sysrq_key_table_lock, flags);
476	return retval;	476	return retval;
477	}	477	}
478		478
479	int register_sysrq_key(int key, struct sysrq_key_op *op_p)	479	int register_sysrq_key(int key, struct sysrq_key_op *op_p)
480	{	480	{
481	return __sysrq_swap_key_ops(key, op_p, NULL);	481	return __sysrq_swap_key_ops(key, op_p, NULL);
482	}	482	}
483	EXPORT_SYMBOL(register_sysrq_key);	483	EXPORT_SYMBOL(register_sysrq_key);
484		484
485	int unregister_sysrq_key(int key, struct sysrq_key_op *op_p)	485	int unregister_sysrq_key(int key, struct sysrq_key_op *op_p)
486	{	486	{
487	return __sysrq_swap_key_ops(key, NULL, op_p);	487	return __sysrq_swap_key_ops(key, NULL, op_p);
488	}	488	}
489	EXPORT_SYMBOL(unregister_sysrq_key);	489	EXPORT_SYMBOL(unregister_sysrq_key);
490		490

drivers/char/vt.c

Diff comments View file @ 2e8ecb9

 /*
  *  linux/drivers/char/vt.c
  *
  *  Copyright (C) 1991, 1992  Linus Torvalds
  */
 /*
  * Hopefully this will be a rather complete VT102 implementation.
  *
  * Beeping thanks to John T Kohl.
  *
  * Virtual Consoles, Screen Blanking, Screen Dumping, Color, Graphics
  *   Chars, and VT100 enhancements by Peter MacDonald.
  *
  * Copy and paste function by Andrew Haylett,
  *   some enhancements by Alessandro Rubini.
  *
  * Code to check for different video-cards mostly by Galen Hunt,
  * <g-hunt@ee.utah.edu>
  *
  * Rudimentary ISO 10646/Unicode/UTF-8 character set support by
  * Markus Kuhn, <mskuhn@immd4.informatik.uni-erlangen.de>.
  *
  * Dynamic allocation of consoles, aeb@cwi.nl, May 1994
  * Resizing of consoles, aeb, 940926
  *
  * Code for xterm like mouse click reporting by Peter Orbaek 20-Jul-94
  * <poe@daimi.aau.dk>
  *
  * User-defined bell sound, new setterm control sequences and printk
  * redirection by Martin Mares <mj@k332.feld.cvut.cz> 19-Nov-95
  *
  * APM screenblank bug fixed Takashi Manabe <manabe@roy.dsl.tutics.tut.jp>
  *
  * Merge with the abstract console driver by Geert Uytterhoeven
  * <geert@linux-m68k.org>, Jan 1997.
  *
  *   Original m68k console driver modifications by
  *
  *     - Arno Griffioen <arno@usn.nl>
  *     - David Carter <carter@cs.bris.ac.uk>
  *
  *   The abstract console driver provides a generic interface for a text
  *   console. It supports VGA text mode, frame buffer based graphical consoles
  *   and special graphics processors that are only accessible through some
  *   registers (e.g. a TMS340x0 GSP).
  *
  *   The interface to the hardware is specified using a special structure
  *   (struct consw) which contains function pointers to console operations
  *   (see <linux/console.h> for more information).
  *
  * Support for changeable cursor shape
  * by Pavel Machek <pavel@atrey.karlin.mff.cuni.cz>, August 1997
  *
  * Ported to i386 and con_scrolldelta fixed
  * by Emmanuel Marty <core@ggi-project.org>, April 1998
  *
  * Resurrected character buffers in videoram plus lots of other trickery
  * by Martin Mares <mj@atrey.karlin.mff.cuni.cz>, July 1998
  *
  * Removed old-style timers, introduced console_timer, made timer
  * deletion SMP-safe.  17Jun00, Andrew Morton <andrewm@uow.edu.au>
  *
  * Removed console_lock, enabled interrupts across all console operations
  * 13 March 2001, Andrew Morton
  *
  * Fixed UTF-8 mode so alternate charset modes always work according
  * to control sequences interpreted in do_con_trol function
  * preserving backward VT100 semigraphics compatibility,
  * malformed UTF sequences represented as sequences of replacement glyphs,
  * original codes or '?' as a last resort if replacement glyph is undefined
  * by Adam Tla/lka <atlka@pg.gda.pl>, Aug 2006
  */
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/sched.h>
 #include <linux/tty.h>
 #include <linux/tty_flip.h>
 #include <linux/kernel.h>
 #include <linux/string.h>
 #include <linux/errno.h>
 #include <linux/kd.h>
 #include <linux/slab.h>
 #include <linux/major.h>
 #include <linux/mm.h>
 #include <linux/console.h>
 #include <linux/init.h>
 #include <linux/mutex.h>
 #include <linux/vt_kern.h>
 #include <linux/selection.h>
 #include <linux/tiocl.h>
 #include <linux/kbd_kern.h>
 #include <linux/consolemap.h>
 #include <linux/timer.h>
 #include <linux/interrupt.h>
 #include <linux/workqueue.h>
 #include <linux/bootmem.h>
 #include <linux/pm.h>
 #include <linux/font.h>
 #include <linux/bitops.h>
 #include <asm/io.h>
 #include <asm/system.h>
 #include <asm/uaccess.h>
 #define MAX_NR_CON_DRIVER 16
 #define CON_DRIVER_FLAG_MODULE 1
 #define CON_DRIVER_FLAG_INIT   2
 #define CON_DRIVER_FLAG_ATTR   4
 struct con_driver {
 	const struct consw *con;
 	const char *desc;
 	struct device *dev;
 	int node;
 	int first;
 	int last;
 	int flag;
 };
 static struct con_driver registered_con_driver[MAX_NR_CON_DRIVER];
 const struct consw *conswitchp;
 /* A bitmap for codes <32. A bit of 1 indicates that the code
  * corresponding to that bit number invokes some special action
  * (such as cursor movement) and should not be displayed as a
  * glyph unless the disp_ctrl mode is explicitly enabled.
  */
 #define CTRL_ACTION 0x0d00ff81
 #define CTRL_ALWAYS 0x0800f501	/* Cannot be overridden by disp_ctrl */
 /*
  * Here is the default bell parameters: 750HZ, 1/8th of a second
  */
 #define DEFAULT_BELL_PITCH	750
 #define DEFAULT_BELL_DURATION	(HZ/8)
 struct vc vc_cons [MAX_NR_CONSOLES];
 #ifndef VT_SINGLE_DRIVER
 static const struct consw *con_driver_map[MAX_NR_CONSOLES];
 #endif
 static int con_open(struct tty_struct *, struct file *);
 static void vc_init(struct vc_data *vc, unsigned int rows,
 		    unsigned int cols, int do_clear);
 static void gotoxy(struct vc_data *vc, int new_x, int new_y);
 static void save_cur(struct vc_data *vc);
 static void reset_terminal(struct vc_data *vc, int do_clear);
 static void con_flush_chars(struct tty_struct *tty);
 static int set_vesa_blanking(char __user *p);
 static void set_cursor(struct vc_data *vc);
 static void hide_cursor(struct vc_data *vc);
 static void console_callback(struct work_struct *ignored);
 static void blank_screen_t(unsigned long dummy);
 static void set_palette(struct vc_data *vc);
 static int printable;		/* Is console ready for printing? */
-static int default_utf8;
+#ifdef CONFIG_VT_UNICODE
+int default_utf8 = 1;
+#else
+int default_utf8;
+#endif
 module_param(default_utf8, int, S_IRUGO | S_IWUSR);
 /*
  * ignore_poke: don't unblank the screen when things are typed.  This is
  * mainly for the privacy of braille terminal users.
  */
 static int ignore_poke;
 int do_poke_blanked_console;
 int console_blanked;
 static int vesa_blank_mode; /* 0:none 1:suspendV 2:suspendH 3:powerdown */
 static int blankinterval = 10*60*HZ;
 static int vesa_off_interval;
 static DECLARE_WORK(console_work, console_callback);
 /*
  * fg_console is the current virtual console,
  * last_console is the last used one,
  * want_console is the console we want to switch to,
  * kmsg_redirect is the console for kernel messages,
  */
 int fg_console;
 int last_console;
 int want_console = -1;
 int kmsg_redirect;
 /*
  * For each existing display, we have a pointer to console currently visible
  * on that display, allowing consoles other than fg_console to be refreshed
  * appropriately. Unless the low-level driver supplies its own display_fg
  * variable, we use this one for the "master display".
  */
 static struct vc_data *master_display_fg;
 /*
  * Unfortunately, we need to delay tty echo when we're currently writing to the
  * console since the code is (and always was) not re-entrant, so we schedule
  * all flip requests to process context with schedule-task() and run it from
  * console_callback().
  */
 /*
  * For the same reason, we defer scrollback to the console callback.
  */
 static int scrollback_delta;
 /*
  * Hook so that the power management routines can (un)blank
  * the console on our behalf.
  */
 int (*console_blank_hook)(int);
 static DEFINE_TIMER(console_timer, blank_screen_t, 0, 0);
 static int blank_state;
 static int blank_timer_expired;
 enum {
 	blank_off = 0,
 	blank_normal_wait,
 	blank_vesa_wait,
 };
 /*
  *	Low-Level Functions
  */
 #define IS_FG(vc)	((vc)->vc_num == fg_console)
 #ifdef VT_BUF_VRAM_ONLY
 #define DO_UPDATE(vc)	0
 #else
 #define DO_UPDATE(vc)	CON_IS_VISIBLE(vc)
 #endif
 static inline unsigned short *screenpos(struct vc_data *vc, int offset, int viewed)
 {
 	unsigned short *p;
 	if (!viewed)
 		p = (unsigned short *)(vc->vc_origin + offset);
 	else if (!vc->vc_sw->con_screen_pos)
 		p = (unsigned short *)(vc->vc_visible_origin + offset);
 	else
 		p = vc->vc_sw->con_screen_pos(vc, offset);
 	return p;
 }
 static inline void scrolldelta(int lines)
 {
 	scrollback_delta += lines;
 	schedule_console_callback();
 }
 void schedule_console_callback(void)
 {
 	schedule_work(&console_work);
 }
 static void scrup(struct vc_data *vc, unsigned int t, unsigned int b, int nr)
 {
 	unsigned short *d, *s;
 	if (t+nr >= b)
 		nr = b - t - 1;
 	if (b > vc->vc_rows || t >= b || nr < 1)
 		return;
 	if (CON_IS_VISIBLE(vc) && vc->vc_sw->con_scroll(vc, t, b, SM_UP, nr))
 		return;
 	d = (unsigned short *)(vc->vc_origin + vc->vc_size_row * t);
 	s = (unsigned short *)(vc->vc_origin + vc->vc_size_row * (t + nr));
 	scr_memmovew(d, s, (b - t - nr) * vc->vc_size_row);
 	scr_memsetw(d + (b - t - nr) * vc->vc_cols, vc->vc_video_erase_char,
 		    vc->vc_size_row * nr);
 }
 static void scrdown(struct vc_data *vc, unsigned int t, unsigned int b, int nr)
 {
 	unsigned short *s;
 	unsigned int step;
 	if (t+nr >= b)
 		nr = b - t - 1;
 	if (b > vc->vc_rows || t >= b || nr < 1)
 		return;
 	if (CON_IS_VISIBLE(vc) && vc->vc_sw->con_scroll(vc, t, b, SM_DOWN, nr))
 		return;
 	s = (unsigned short *)(vc->vc_origin + vc->vc_size_row * t);
 	step = vc->vc_cols * nr;
 	scr_memmovew(s + step, s, (b - t - nr) * vc->vc_size_row);
 	scr_memsetw(s, vc->vc_video_erase_char, 2 * step);
 }
 static void do_update_region(struct vc_data *vc, unsigned long start, int count)
 {
 #ifndef VT_BUF_VRAM_ONLY
 	unsigned int xx, yy, offset;
 	u16 *p;
 	p = (u16 *) start;
 	if (!vc->vc_sw->con_getxy) {
 		offset = (start - vc->vc_origin) / 2;
 		xx = offset % vc->vc_cols;
 		yy = offset / vc->vc_cols;
 	} else {
 		int nxx, nyy;
 		start = vc->vc_sw->con_getxy(vc, start, &nxx, &nyy);
 		xx = nxx; yy = nyy;
 	}
 	for(;;) {
 		u16 attrib = scr_readw(p) & 0xff00;
 		int startx = xx;
 		u16 *q = p;
 		while (xx < vc->vc_cols && count) {
 			if (attrib != (scr_readw(p) & 0xff00)) {
 				if (p > q)
 					vc->vc_sw->con_putcs(vc, q, p-q, yy, startx);
 				startx = xx;
 				q = p;
 				attrib = scr_readw(p) & 0xff00;
 			}
 			p++;
 			xx++;
 			count--;
 		}
 		if (p > q)
 			vc->vc_sw->con_putcs(vc, q, p-q, yy, startx);
 		if (!count)
 			break;
 		xx = 0;
 		yy++;
 		if (vc->vc_sw->con_getxy) {
 			p = (u16 *)start;
 			start = vc->vc_sw->con_getxy(vc, start, NULL, NULL);
 		}
 	}
 #endif
 }
 void update_region(struct vc_data *vc, unsigned long start, int count)
 {
 	WARN_CONSOLE_UNLOCKED();
 	if (DO_UPDATE(vc)) {
 		hide_cursor(vc);
 		do_update_region(vc, start, count);
 		set_cursor(vc);
 	}
 }
 /* Structure of attributes is hardware-dependent */
 static u8 build_attr(struct vc_data *vc, u8 _color, u8 _intensity, u8 _blink,
     u8 _underline, u8 _reverse, u8 _italic)
 {
 	if (vc->vc_sw->con_build_attr)
 		return vc->vc_sw->con_build_attr(vc, _color, _intensity,
 		       _blink, _underline, _reverse, _italic);
 #ifndef VT_BUF_VRAM_ONLY
 /*
  * ++roman: I completely changed the attribute format for monochrome
  * mode (!can_do_color). The formerly used MDA (monochrome display
  * adapter) format didn't allow the combination of certain effects.
  * Now the attribute is just a bit vector:
  *  Bit 0..1: intensity (0..2)
  *  Bit 2   : underline
  *  Bit 3   : reverse
  *  Bit 7   : blink
  */
 	{
 	u8 a = vc->vc_color;
 	if (!vc->vc_can_do_color)
 		return _intensity |
 		       (_italic ? 2 : 0) |
 		       (_underline ? 4 : 0) |
 		       (_reverse ? 8 : 0) |
 		       (_blink ? 0x80 : 0);
 	if (_italic)
 		a = (a & 0xF0) | vc->vc_itcolor;
 	else if (_underline)
 		a = (a & 0xf0) | vc->vc_ulcolor;
 	else if (_intensity == 0)
 		a = (a & 0xf0) | vc->vc_ulcolor;
 	if (_reverse)
 		a = ((a) & 0x88) | ((((a) >> 4) | ((a) << 4)) & 0x77);
 	if (_blink)
 		a ^= 0x80;
 	if (_intensity == 2)
 		a ^= 0x08;
 	if (vc->vc_hi_font_mask == 0x100)
 		a <<= 1;
 	return a;
 	}
 #else
 	return 0;
 #endif
 }
 static void update_attr(struct vc_data *vc)
 {
 	vc->vc_attr = build_attr(vc, vc->vc_color, vc->vc_intensity,
 	              vc->vc_blink, vc->vc_underline,
 	              vc->vc_reverse ^ vc->vc_decscnm, vc->vc_italic);
 	vc->vc_video_erase_char = (build_attr(vc, vc->vc_color, 1, vc->vc_blink, 0, vc->vc_decscnm, 0) << 8) | ' ';
 }
 /* Note: inverting the screen twice should revert to the original state */
 void invert_screen(struct vc_data *vc, int offset, int count, int viewed)
 {
 	unsigned short *p;
 	WARN_CONSOLE_UNLOCKED();
 	count /= 2;
 	p = screenpos(vc, offset, viewed);
 	if (vc->vc_sw->con_invert_region)
 		vc->vc_sw->con_invert_region(vc, p, count);
 #ifndef VT_BUF_VRAM_ONLY
 	else {
 		u16 *q = p;
 		int cnt = count;
 		u16 a;
 		if (!vc->vc_can_do_color) {
 			while (cnt--) {
 			    a = scr_readw(q);
 			    a ^= 0x0800;
 			    scr_writew(a, q);
 			    q++;
 			}
 		} else if (vc->vc_hi_font_mask == 0x100) {
 			while (cnt--) {
 				a = scr_readw(q);
 				a = ((a) & 0x11ff) | (((a) & 0xe000) >> 4) | (((a) & 0x0e00) << 4);
 				scr_writew(a, q);
 				q++;
 			}
 		} else {
 			while (cnt--) {
 				a = scr_readw(q);
 				a = ((a) & 0x88ff) | (((a) & 0x7000) >> 4) | (((a) & 0x0700) << 4);
 				scr_writew(a, q);
 				q++;
 			}
 		}
 	}
 #endif
 	if (DO_UPDATE(vc))
 		do_update_region(vc, (unsigned long) p, count);
 }
 /* used by selection: complement pointer position */
 void complement_pos(struct vc_data *vc, int offset)
 {
 	static int old_offset = -1;
 	static unsigned short old;
 	static unsigned short oldx, oldy;
 	WARN_CONSOLE_UNLOCKED();
 	if (old_offset != -1 && old_offset >= 0 &&
 	    old_offset < vc->vc_screenbuf_size) {
 		scr_writew(old, screenpos(vc, old_offset, 1));
 		if (DO_UPDATE(vc))
 			vc->vc_sw->con_putc(vc, old, oldy, oldx);
 	}
 	old_offset = offset;
 	if (offset != -1 && offset >= 0 &&
 	    offset < vc->vc_screenbuf_size) {
 		unsigned short new;
 		unsigned short *p;
 		p = screenpos(vc, offset, 1);
 		old = scr_readw(p);
 		new = old ^ vc->vc_complement_mask;
 		scr_writew(new, p);
 		if (DO_UPDATE(vc)) {
 			oldx = (offset >> 1) % vc->vc_cols;
 			oldy = (offset >> 1) / vc->vc_cols;
 			vc->vc_sw->con_putc(vc, new, oldy, oldx);
 		}
 	}
 }
 static void insert_char(struct vc_data *vc, unsigned int nr)
 {
 	unsigned short *p, *q = (unsigned short *)vc->vc_pos;
 	p = q + vc->vc_cols - nr - vc->vc_x;
 	while (--p >= q)
 		scr_writew(scr_readw(p), p + nr);
 	scr_memsetw(q, vc->vc_video_erase_char, nr * 2);
 	vc->vc_need_wrap = 0;
 	if (DO_UPDATE(vc)) {
 		unsigned short oldattr = vc->vc_attr;
 		vc->vc_sw->con_bmove(vc, vc->vc_y, vc->vc_x, vc->vc_y, vc->vc_x + nr, 1,
 				     vc->vc_cols - vc->vc_x - nr);
 		vc->vc_attr = vc->vc_video_erase_char >> 8;
 		while (nr--)
 			vc->vc_sw->con_putc(vc, vc->vc_video_erase_char, vc->vc_y, vc->vc_x + nr);
 		vc->vc_attr = oldattr;
 	}
 }
 static void delete_char(struct vc_data *vc, unsigned int nr)
 {
 	unsigned int i = vc->vc_x;
 	unsigned short *p = (unsigned short *)vc->vc_pos;
 	while (++i <= vc->vc_cols - nr) {
 		scr_writew(scr_readw(p+nr), p);
 		p++;
 	}
 	scr_memsetw(p, vc->vc_video_erase_char, nr * 2);
 	vc->vc_need_wrap = 0;
 	if (DO_UPDATE(vc)) {
 		unsigned short oldattr = vc->vc_attr;
 		vc->vc_sw->con_bmove(vc, vc->vc_y, vc->vc_x + nr, vc->vc_y, vc->vc_x, 1,
 				     vc->vc_cols - vc->vc_x - nr);
 		vc->vc_attr = vc->vc_video_erase_char >> 8;
 		while (nr--)
 			vc->vc_sw->con_putc(vc, vc->vc_video_erase_char, vc->vc_y,
 				     vc->vc_cols - 1 - nr);
 		vc->vc_attr = oldattr;
 	}
 }
 static int softcursor_original;
 static void add_softcursor(struct vc_data *vc)
 {
 	int i = scr_readw((u16 *) vc->vc_pos);
 	u32 type = vc->vc_cursor_type;
 	if (! (type & 0x10)) return;
 	if (softcursor_original != -1) return;
 	softcursor_original = i;
 	i |= ((type >> 8) & 0xff00 );
 	i ^= ((type) & 0xff00 );
 	if ((type & 0x20) && ((softcursor_original & 0x7000) == (i & 0x7000))) i ^= 0x7000;
 	if ((type & 0x40) && ((i & 0x700) == ((i & 0x7000) >> 4))) i ^= 0x0700;
 	scr_writew(i, (u16 *) vc->vc_pos);
 	if (DO_UPDATE(vc))
 		vc->vc_sw->con_putc(vc, i, vc->vc_y, vc->vc_x);
 }
 static void hide_softcursor(struct vc_data *vc)
 {
 	if (softcursor_original != -1) {
 		scr_writew(softcursor_original, (u16 *)vc->vc_pos);
 		if (DO_UPDATE(vc))
 			vc->vc_sw->con_putc(vc, softcursor_original,
 					vc->vc_y, vc->vc_x);
 		softcursor_original = -1;
 	}
 }
 static void hide_cursor(struct vc_data *vc)
 {
 	if (vc == sel_cons)
 		clear_selection();
 	vc->vc_sw->con_cursor(vc, CM_ERASE);
 	hide_softcursor(vc);
 }
 static void set_cursor(struct vc_data *vc)
 {
 	if (!IS_FG(vc) || console_blanked ||
 	    vc->vc_mode == KD_GRAPHICS)
 		return;
 	if (vc->vc_deccm) {
 		if (vc == sel_cons)
 			clear_selection();
 		add_softcursor(vc);
 		if ((vc->vc_cursor_type & 0x0f) != 1)
 			vc->vc_sw->con_cursor(vc, CM_DRAW);
 	} else
 		hide_cursor(vc);
 }
 static void set_origin(struct vc_data *vc)
 {
 	WARN_CONSOLE_UNLOCKED();
 	if (!CON_IS_VISIBLE(vc) ||
 	    !vc->vc_sw->con_set_origin ||
 	    !vc->vc_sw->con_set_origin(vc))
 		vc->vc_origin = (unsigned long)vc->vc_screenbuf;
 	vc->vc_visible_origin = vc->vc_origin;
 	vc->vc_scr_end = vc->vc_origin + vc->vc_screenbuf_size;
 	vc->vc_pos = vc->vc_origin + vc->vc_size_row * vc->vc_y + 2 * vc->vc_x;
 }
 static inline void save_screen(struct vc_data *vc)
 {
 	WARN_CONSOLE_UNLOCKED();
 	if (vc->vc_sw->con_save_screen)
 		vc->vc_sw->con_save_screen(vc);
 }
 /*
  *	Redrawing of screen
  */
 static void clear_buffer_attributes(struct vc_data *vc)
 {
 	unsigned short *p = (unsigned short *)vc->vc_origin;
 	int count = vc->vc_screenbuf_size / 2;
 	int mask = vc->vc_hi_font_mask | 0xff;
 	for (; count > 0; count--, p++) {
 		scr_writew((scr_readw(p)&mask) | (vc->vc_video_erase_char & ~mask), p);
 	}
 }
 void redraw_screen(struct vc_data *vc, int is_switch)
 {
 	int redraw = 0;
 	WARN_CONSOLE_UNLOCKED();
 	if (!vc) {
 		/* strange ... */
 		/* printk("redraw_screen: tty %d not allocated ??\n", new_console+1); */
 		return;
 	}
 	if (is_switch) {
 		struct vc_data *old_vc = vc_cons[fg_console].d;
 		if (old_vc == vc)
 			return;
 		if (!CON_IS_VISIBLE(vc))
 			redraw = 1;
 		*vc->vc_display_fg = vc;
 		fg_console = vc->vc_num;
 		hide_cursor(old_vc);
 		if (!CON_IS_VISIBLE(old_vc)) {
 			save_screen(old_vc);
 			set_origin(old_vc);
 		}
 	} else {
 		hide_cursor(vc);
 		redraw = 1;
 	}
 	if (redraw) {
 		int update;
 		int old_was_color = vc->vc_can_do_color;
 		set_origin(vc);
 		update = vc->vc_sw->con_switch(vc);
 		set_palette(vc);
 		/*
 		 * If console changed from mono<->color, the best we can do
 		 * is to clear the buffer attributes. As it currently stands,
 		 * rebuilding new attributes from the old buffer is not doable
 		 * without overly complex code.
 		 */
 		if (old_was_color != vc->vc_can_do_color) {
 			update_attr(vc);
 			clear_buffer_attributes(vc);
 		}
 		if (update && vc->vc_mode != KD_GRAPHICS)
 			do_update_region(vc, vc->vc_origin, vc->vc_screenbuf_size / 2);
 	}
 	set_cursor(vc);
 	if (is_switch) {
 		set_leds();
 		compute_shiftstate();
 	}
 }
 /*
  *	Allocation, freeing and resizing of VTs.
  */
 int vc_cons_allocated(unsigned int i)
 {
 	return (i < MAX_NR_CONSOLES && vc_cons[i].d);
 }
 static void visual_init(struct vc_data *vc, int num, int init)
 {
 	/* ++Geert: vc->vc_sw->con_init determines console size */
 	if (vc->vc_sw)
 		module_put(vc->vc_sw->owner);
 	vc->vc_sw = conswitchp;
 #ifndef VT_SINGLE_DRIVER
 	if (con_driver_map[num])
 		vc->vc_sw = con_driver_map[num];
 #endif
 	__module_get(vc->vc_sw->owner);
 	vc->vc_num = num;
 	vc->vc_display_fg = &master_display_fg;
 	vc->vc_uni_pagedir_loc = &vc->vc_uni_pagedir;
 	vc->vc_uni_pagedir = 0;
 	vc->vc_hi_font_mask = 0;
 	vc->vc_complement_mask = 0;
 	vc->vc_can_do_color = 0;
 	vc->vc_sw->con_init(vc, init);
 	if (!vc->vc_complement_mask)
 		vc->vc_complement_mask = vc->vc_can_do_color ? 0x7700 : 0x0800;
 	vc->vc_s_complement_mask = vc->vc_complement_mask;
 	vc->vc_size_row = vc->vc_cols << 1;
 	vc->vc_screenbuf_size = vc->vc_rows * vc->vc_size_row;
 }
 int vc_allocate(unsigned int currcons)	/* return 0 on success */
 {
 	WARN_CONSOLE_UNLOCKED();
 	if (currcons >= MAX_NR_CONSOLES)
 		return -ENXIO;
 	if (!vc_cons[currcons].d) {
 	    struct vc_data *vc;
 	    /* prevent users from taking too much memory */
 	    if (currcons >= MAX_NR_USER_CONSOLES && !capable(CAP_SYS_RESOURCE))
 	      return -EPERM;
 	    /* due to the granularity of kmalloc, we waste some memory here */
 	    /* the alloc is done in two steps, to optimize the common situation
 	       of a 25x80 console (structsize=216, screenbuf_size=4000) */
 	    /* although the numbers above are not valid since long ago, the
 	       point is still up-to-date and the comment still has its value
 	       even if only as a historical artifact.  --mj, July 1998 */
 	    vc = kzalloc(sizeof(struct vc_data), GFP_KERNEL);
 	    if (!vc)
 		return -ENOMEM;
 	    vc_cons[currcons].d = vc;
 	    INIT_WORK(&vc_cons[currcons].SAK_work, vc_SAK);
 	    visual_init(vc, currcons, 1);
 	    if (!*vc->vc_uni_pagedir_loc)
 		con_set_default_unimap(vc);
 	    if (!vc->vc_kmalloced)
 		vc->vc_screenbuf = kmalloc(vc->vc_screenbuf_size, GFP_KERNEL);
 	    if (!vc->vc_screenbuf) {
 		kfree(vc);
 		vc_cons[currcons].d = NULL;
 		return -ENOMEM;
 	    }
 	    vc->vc_kmalloced = 1;
 	    vc_init(vc, vc->vc_rows, vc->vc_cols, 1);
 	}
 	return 0;
 }
 static inline int resize_screen(struct vc_data *vc, int width, int height,
 				int user)
 {
 	/* Resizes the resolution of the display adapater */
 	int err = 0;
 	if (vc->vc_mode != KD_GRAPHICS && vc->vc_sw->con_resize)
 		err = vc->vc_sw->con_resize(vc, width, height, user);
 	return err;
 }
 /*
  * Change # of rows and columns (0 means unchanged/the size of fg_console)
  * [this is to be used together with some user program
  * like resize that changes the hardware videomode]
  */
 #define VC_RESIZE_MAXCOL (32767)
 #define VC_RESIZE_MAXROW (32767)
 int vc_resize(struct vc_data *vc, unsigned int cols, unsigned int lines)
 {
 	unsigned long old_origin, new_origin, new_scr_end, rlth, rrem, err = 0;
 	unsigned int old_cols, old_rows, old_row_size, old_screen_size;
 	unsigned int new_cols, new_rows, new_row_size, new_screen_size;
 	unsigned int end, user;
 	unsigned short *newscreen;
 	WARN_CONSOLE_UNLOCKED();
 	if (!vc)
 		return -ENXIO;
 	user = vc->vc_resize_user;
 	vc->vc_resize_user = 0;
 	if (cols > VC_RESIZE_MAXCOL || lines > VC_RESIZE_MAXROW)
 		return -EINVAL;
 	new_cols = (cols ? cols : vc->vc_cols);
 	new_rows = (lines ? lines : vc->vc_rows);
 	new_row_size = new_cols << 1;
 	new_screen_size = new_row_size * new_rows;
 	if (new_cols == vc->vc_cols && new_rows == vc->vc_rows)
 		return 0;
 	newscreen = kmalloc(new_screen_size, GFP_USER);
 	if (!newscreen)
 		return -ENOMEM;
 	old_rows = vc->vc_rows;
 	old_cols = vc->vc_cols;
 	old_row_size = vc->vc_size_row;
 	old_screen_size = vc->vc_screenbuf_size;
 	err = resize_screen(vc, new_cols, new_rows, user);
 	if (err) {
 		kfree(newscreen);
 		return err;
 	}
 	vc->vc_rows = new_rows;
 	vc->vc_cols = new_cols;
 	vc->vc_size_row = new_row_size;
 	vc->vc_screenbuf_size = new_screen_size;
 	rlth = min(old_row_size, new_row_size);
 	rrem = new_row_size - rlth;
 	old_origin = vc->vc_origin;
 	new_origin = (long) newscreen;
 	new_scr_end = new_origin + new_screen_size;
 	if (vc->vc_y > new_rows) {
 		if (old_rows - vc->vc_y < new_rows) {
 			/*
 			 * Cursor near the bottom, copy contents from the
 			 * bottom of buffer
 			 */
 			old_origin += (old_rows - new_rows) * old_row_size;
 			end = vc->vc_scr_end;
 		} else {
 			/*
 			 * Cursor is in no man's land, copy 1/2 screenful
 			 * from the top and bottom of cursor position
 			 */
 			old_origin += (vc->vc_y - new_rows/2) * old_row_size;
 			end = old_origin + (old_row_size * new_rows);
 		}
 	} else
 		/*
 		 * Cursor near the top, copy contents from the top of buffer
 		 */
 		end = (old_rows > new_rows) ? old_origin +
 			(old_row_size * new_rows) :
 			vc->vc_scr_end;
 	update_attr(vc);
 	while (old_origin < end) {
 		scr_memcpyw((unsigned short *) new_origin,
 			    (unsigned short *) old_origin, rlth);
 		if (rrem)
 			scr_memsetw((void *)(new_origin + rlth),
 				    vc->vc_video_erase_char, rrem);
 		old_origin += old_row_size;
 		new_origin += new_row_size;
 	}
 	if (new_scr_end > new_origin)
 		scr_memsetw((void *)new_origin, vc->vc_video_erase_char,
 			    new_scr_end - new_origin);
 	if (vc->vc_kmalloced)
 		kfree(vc->vc_screenbuf);
 	vc->vc_screenbuf = newscreen;
 	vc->vc_kmalloced = 1;
 	vc->vc_screenbuf_size = new_screen_size;
 	set_origin(vc);
 	/* do part of a reset_terminal() */
 	vc->vc_top = 0;
 	vc->vc_bottom = vc->vc_rows;
 	gotoxy(vc, vc->vc_x, vc->vc_y);
 	save_cur(vc);
 	if (vc->vc_tty) {
 		struct winsize ws, *cws = &vc->vc_tty->winsize;
 		memset(&ws, 0, sizeof(ws));
 		ws.ws_row = vc->vc_rows;
 		ws.ws_col = vc->vc_cols;
 		ws.ws_ypixel = vc->vc_scan_lines;
 		if ((ws.ws_row != cws->ws_row || ws.ws_col != cws->ws_col) &&
 		    vc->vc_tty->pgrp)
 			kill_pgrp(vc->vc_tty->pgrp, SIGWINCH, 1);
 		*cws = ws;
 	}
 	if (CON_IS_VISIBLE(vc))
 		update_screen(vc);
 	return err;
 }
 int vc_lock_resize(struct vc_data *vc, unsigned int cols, unsigned int lines)
 {
 	int rc;
 	acquire_console_sem();
 	rc = vc_resize(vc, cols, lines);
 	release_console_sem();
 	return rc;
 }
 void vc_deallocate(unsigned int currcons)
 {
 	WARN_CONSOLE_UNLOCKED();
 	if (vc_cons_allocated(currcons)) {
 		struct vc_data *vc = vc_cons[currcons].d;
 		vc->vc_sw->con_deinit(vc);
 		put_pid(vc->vt_pid);
 		module_put(vc->vc_sw->owner);
 		if (vc->vc_kmalloced)
 			kfree(vc->vc_screenbuf);
 		if (currcons >= MIN_NR_CONSOLES)
 			kfree(vc);
 		vc_cons[currcons].d = NULL;
 	}
 }
 /*
  *	VT102 emulator
  */
 #define set_kbd(vc, x)	set_vc_kbd_mode(kbd_table + (vc)->vc_num, (x))
 #define clr_kbd(vc, x)	clr_vc_kbd_mode(kbd_table + (vc)->vc_num, (x))
 #define is_kbd(vc, x)	vc_kbd_mode(kbd_table + (vc)->vc_num, (x))
 #define decarm		VC_REPEAT
 #define decckm		VC_CKMODE
 #define kbdapplic	VC_APPLIC
 #define lnm		VC_CRLF
 /*
  * this is what the terminal answers to a ESC-Z or csi0c query.
  */
 #define VT100ID "\033[?1;2c"
 #define VT102ID "\033[?6c"
 unsigned char color_table[] = { 0, 4, 2, 6, 1, 5, 3, 7,
 				       8,12,10,14, 9,13,11,15 };
 /* the default colour table, for VGA+ colour systems */
 int default_red[] = {0x00,0xaa,0x00,0xaa,0x00,0xaa,0x00,0xaa,
     0x55,0xff,0x55,0xff,0x55,0xff,0x55,0xff};
 int default_grn[] = {0x00,0x00,0xaa,0x55,0x00,0x00,0xaa,0xaa,
     0x55,0x55,0xff,0xff,0x55,0x55,0xff,0xff};
 int default_blu[] = {0x00,0x00,0x00,0x00,0xaa,0xaa,0xaa,0xaa,
     0x55,0x55,0x55,0x55,0xff,0xff,0xff,0xff};
 module_param_array(default_red, int, NULL, S_IRUGO | S_IWUSR);
 module_param_array(default_grn, int, NULL, S_IRUGO | S_IWUSR);
 module_param_array(default_blu, int, NULL, S_IRUGO | S_IWUSR);
 /*
  * gotoxy() must verify all boundaries, because the arguments
  * might also be negative. If the given position is out of
  * bounds, the cursor is placed at the nearest margin.
  */
 static void gotoxy(struct vc_data *vc, int new_x, int new_y)
 {
 	int min_y, max_y;
 	if (new_x < 0)
 		vc->vc_x = 0;
 	else {
 		if (new_x >= vc->vc_cols)
 			vc->vc_x = vc->vc_cols - 1;
 		else
 			vc->vc_x = new_x;
 	}
  	if (vc->vc_decom) {
 		min_y = vc->vc_top;
 		max_y = vc->vc_bottom;
 	} else {
 		min_y = 0;
 		max_y = vc->vc_rows;
 	}
 	if (new_y < min_y)
 		vc->vc_y = min_y;
 	else if (new_y >= max_y)
 		vc->vc_y = max_y - 1;
 	else
 		vc->vc_y = new_y;
 	vc->vc_pos = vc->vc_origin + vc->vc_y * vc->vc_size_row + (vc->vc_x<<1);
 	vc->vc_need_wrap = 0;
 }
 /* for absolute user moves, when decom is set */
 static void gotoxay(struct vc_data *vc, int new_x, int new_y)
 {
 	gotoxy(vc, new_x, vc->vc_decom ? (vc->vc_top + new_y) : new_y);
 }
 void scrollback(struct vc_data *vc, int lines)
 {
 	if (!lines)
 		lines = vc->vc_rows / 2;
 	scrolldelta(-lines);
 }
 void scrollfront(struct vc_data *vc, int lines)
 {
 	if (!lines)
 		lines = vc->vc_rows / 2;
 	scrolldelta(lines);
 }
 static void lf(struct vc_data *vc)
 {
     	/* don't scroll if above bottom of scrolling region, or
 	 * if below scrolling region
 	 */
     	if (vc->vc_y + 1 == vc->vc_bottom)
 		scrup(vc, vc->vc_top, vc->vc_bottom, 1);
 	else if (vc->vc_y < vc->vc_rows - 1) {
 	    	vc->vc_y++;
 		vc->vc_pos += vc->vc_size_row;
 	}
 	vc->vc_need_wrap = 0;
 }
 static void ri(struct vc_data *vc)
 {
     	/* don't scroll if below top of scrolling region, or
 	 * if above scrolling region
 	 */
 	if (vc->vc_y == vc->vc_top)
 		scrdown(vc, vc->vc_top, vc->vc_bottom, 1);
 	else if (vc->vc_y > 0) {
 		vc->vc_y--;
 		vc->vc_pos -= vc->vc_size_row;
 	}
 	vc->vc_need_wrap = 0;
 }
 static inline void cr(struct vc_data *vc)
 {
 	vc->vc_pos -= vc->vc_x << 1;
 	vc->vc_need_wrap = vc->vc_x = 0;
 }
 static inline void bs(struct vc_data *vc)
 {
 	if (vc->vc_x) {
 		vc->vc_pos -= 2;
 		vc->vc_x--;
 		vc->vc_need_wrap = 0;
 	}
 }
 static inline void del(struct vc_data *vc)
 {
 	/* ignored */
 }
 static void csi_J(struct vc_data *vc, int vpar)
 {
 	unsigned int count;
 	unsigned short * start;
 	switch (vpar) {
 		case 0:	/* erase from cursor to end of display */
 			count = (vc->vc_scr_end - vc->vc_pos) >> 1;
 			start = (unsigned short *)vc->vc_pos;
 			if (DO_UPDATE(vc)) {
 				/* do in two stages */
 				vc->vc_sw->con_clear(vc, vc->vc_y, vc->vc_x, 1,
 					      vc->vc_cols - vc->vc_x);
 				vc->vc_sw->con_clear(vc, vc->vc_y + 1, 0,
 					      vc->vc_rows - vc->vc_y - 1,
 					      vc->vc_cols);
 			}
 			break;
 		case 1:	/* erase from start to cursor */
 			count = ((vc->vc_pos - vc->vc_origin) >> 1) + 1;
 			start = (unsigned short *)vc->vc_origin;
 			if (DO_UPDATE(vc)) {
 				/* do in two stages */
 				vc->vc_sw->con_clear(vc, 0, 0, vc->vc_y,
 					      vc->vc_cols);
 				vc->vc_sw->con_clear(vc, vc->vc_y, 0, 1,
 					      vc->vc_x + 1);
 			}
 			break;
 		case 2: /* erase whole display */
 			count = vc->vc_cols * vc->vc_rows;
 			start = (unsigned short *)vc->vc_origin;
 			if (DO_UPDATE(vc))
 				vc->vc_sw->con_clear(vc, 0, 0,
 					      vc->vc_rows,
 					      vc->vc_cols);
 			break;
 		default:
 			return;
 	}
 	scr_memsetw(start, vc->vc_video_erase_char, 2 * count);
 	vc->vc_need_wrap = 0;
 }
 static void csi_K(struct vc_data *vc, int vpar)
 {
 	unsigned int count;
 	unsigned short * start;
 	switch (vpar) {
 		case 0:	/* erase from cursor to end of line */
 			count = vc->vc_cols - vc->vc_x;
 			start = (unsigned short *)vc->vc_pos;
 			if (DO_UPDATE(vc))
 				vc->vc_sw->con_clear(vc, vc->vc_y, vc->vc_x, 1,
 						     vc->vc_cols - vc->vc_x);
 			break;
 		case 1:	/* erase from start of line to cursor */
 			start = (unsigned short *)(vc->vc_pos - (vc->vc_x << 1));
 			count = vc->vc_x + 1;
 			if (DO_UPDATE(vc))
 				vc->vc_sw->con_clear(vc, vc->vc_y, 0, 1,
 						     vc->vc_x + 1);
 			break;
 		case 2: /* erase whole line */
 			start = (unsigned short *)(vc->vc_pos - (vc->vc_x << 1));
 			count = vc->vc_cols;
 			if (DO_UPDATE(vc))
 				vc->vc_sw->con_clear(vc, vc->vc_y, 0, 1,
 					      vc->vc_cols);
 			break;
 		default:
 			return;
 	}
 	scr_memsetw(start, vc->vc_video_erase_char, 2 * count);
 	vc->vc_need_wrap = 0;
 }
 static void csi_X(struct vc_data *vc, int vpar) /* erase the following vpar positions */
 {					  /* not vt100? */
 	int count;
 	if (!vpar)
 		vpar++;
 	count = (vpar > vc->vc_cols - vc->vc_x) ? (vc->vc_cols - vc->vc_x) : vpar;
 	scr_memsetw((unsigned short *)vc->vc_pos, vc->vc_video_erase_char, 2 * count);
 	if (DO_UPDATE(vc))
 		vc->vc_sw->con_clear(vc, vc->vc_y, vc->vc_x, 1, count);
 	vc->vc_need_wrap = 0;
 }
 static void default_attr(struct vc_data *vc)
 {
 	vc->vc_intensity = 1;
 	vc->vc_italic = 0;
 	vc->vc_underline = 0;
 	vc->vc_reverse = 0;
 	vc->vc_blink = 0;
 	vc->vc_color = vc->vc_def_color;
 }
 /* console_sem is held */
 static void csi_m(struct vc_data *vc)
 {
 	int i;
 	for (i = 0; i <= vc->vc_npar; i++)
 		switch (vc->vc_par[i]) {
 			case 0:	/* all attributes off */
 				default_attr(vc);
 				break;
 			case 1:
 				vc->vc_intensity = 2;
 				break;
 			case 2:
 				vc->vc_intensity = 0;
 				break;
 			case 3:
 				vc->vc_italic = 1;
 				break;
 			case 4:
 				vc->vc_underline = 1;
 				break;
 			case 5:
 				vc->vc_blink = 1;
 				break;
 			case 7:
 				vc->vc_reverse = 1;
 				break;
 			case 10: /* ANSI X3.64-1979 (SCO-ish?)
 				  * Select primary font, don't display
 				  * control chars if defined, don't set
 				  * bit 8 on output.
 				  */
 				vc->vc_translate = set_translate(vc->vc_charset == 0
 						? vc->vc_G0_charset
 						: vc->vc_G1_charset, vc);
 				vc->vc_disp_ctrl = 0;
 				vc->vc_toggle_meta = 0;
 				break;
 			case 11: /* ANSI X3.64-1979 (SCO-ish?)
 				  * Select first alternate font, lets
 				  * chars < 32 be displayed as ROM chars.
 				  */
 				vc->vc_translate = set_translate(IBMPC_MAP, vc);
 				vc->vc_disp_ctrl = 1;
 				vc->vc_toggle_meta = 0;
 				break;
 			case 12: /* ANSI X3.64-1979 (SCO-ish?)
 				  * Select second alternate font, toggle
 				  * high bit before displaying as ROM char.
 				  */
 				vc->vc_translate = set_translate(IBMPC_MAP, vc);
 				vc->vc_disp_ctrl = 1;
 				vc->vc_toggle_meta = 1;
 				break;
 			case 21:
 			case 22:
 				vc->vc_intensity = 1;
 				break;
 			case 23:
 				vc->vc_italic = 0;
 				break;
 			case 24:
 				vc->vc_underline = 0;
 				break;
 			case 25:
 				vc->vc_blink = 0;
 				break;
 			case 27:
 				vc->vc_reverse = 0;
 				break;
 			case 38: /* ANSI X3.64-1979 (SCO-ish?)
 				  * Enables underscore, white foreground
 				  * with white underscore (Linux - use
 				  * default foreground).
 				  */
 				vc->vc_color = (vc->vc_def_color & 0x0f) | (vc->vc_color & 0xf0);
 				vc->vc_underline = 1;
 				break;
 			case 39: /* ANSI X3.64-1979 (SCO-ish?)
 				  * Disable underline option.
 				  * Reset colour to default? It did this
 				  * before...
 				  */
 				vc->vc_color = (vc->vc_def_color & 0x0f) | (vc->vc_color & 0xf0);
 				vc->vc_underline = 0;
 				break;
 			case 49:
 				vc->vc_color = (vc->vc_def_color & 0xf0) | (vc->vc_color & 0x0f);
 				break;
 			default:
 				if (vc->vc_par[i] >= 30 && vc->vc_par[i] <= 37)
 					vc->vc_color = color_table[vc->vc_par[i] - 30]
 						| (vc->vc_color & 0xf0);
 				else if (vc->vc_par[i] >= 40 && vc->vc_par[i] <= 47)
 					vc->vc_color = (color_table[vc->vc_par[i] - 40] << 4)
 						| (vc->vc_color & 0x0f);
 				break;
 		}
 	update_attr(vc);
 }
 static void respond_string(const char *p, struct tty_struct *tty)
 {
 	while (*p) {
 		tty_insert_flip_char(tty, *p, 0);
 		p++;
 	}
 	con_schedule_flip(tty);
 }
 static void cursor_report(struct vc_data *vc, struct tty_struct *tty)
 {
 	char buf[40];
 	sprintf(buf, "\033[%d;%dR", vc->vc_y + (vc->vc_decom ? vc->vc_top + 1 : 1), vc->vc_x + 1);
 	respond_string(buf, tty);
 }
 static inline void status_report(struct tty_struct *tty)
 {
 	respond_string("\033[0n", tty);	/* Terminal ok */
 }
 static inline void respond_ID(struct tty_struct * tty)
 {
 	respond_string(VT102ID, tty);
 }
 void mouse_report(struct tty_struct *tty, int butt, int mrx, int mry)
 {
 	char buf[8];
 	sprintf(buf, "\033[M%c%c%c", (char)(' ' + butt), (char)('!' + mrx),
 		(char)('!' + mry));
 	respond_string(buf, tty);
 }
 /* invoked via ioctl(TIOCLINUX) and through set_selection */
 int mouse_reporting(void)
 {
 	return vc_cons[fg_console].d->vc_report_mouse;
 }
 /* console_sem is held */
 static void set_mode(struct vc_data *vc, int on_off)
 {
 	int i;
 	for (i = 0; i <= vc->vc_npar; i++)
 		if (vc->vc_ques) {
 			switch(vc->vc_par[i]) {	/* DEC private modes set/reset */
 			case 1:			/* Cursor keys send ^[Ox/^[[x */
 				if (on_off)
 					set_kbd(vc, decckm);
 				else
 					clr_kbd(vc, decckm);
 				break;
 			case 3:	/* 80/132 mode switch unimplemented */
 				vc->vc_deccolm = on_off;
 #if 0
 				vc_resize(deccolm ? 132 : 80, vc->vc_rows);
 				/* this alone does not suffice; some user mode
 				   utility has to change the hardware regs */
 #endif
 				break;
 			case 5:			/* Inverted screen on/off */
 				if (vc->vc_decscnm != on_off) {
 					vc->vc_decscnm = on_off;
 					invert_screen(vc, 0, vc->vc_screenbuf_size, 0);
 					update_attr(vc);
 				}
 				break;
 			case 6:			/* Origin relative/absolute */
 				vc->vc_decom = on_off;
 				gotoxay(vc, 0, 0);
 				break;
 			case 7:			/* Autowrap on/off */
 				vc->vc_decawm = on_off;
 				break;
 			case 8:			/* Autorepeat on/off */
 				if (on_off)
 					set_kbd(vc, decarm);
 				else
 					clr_kbd(vc, decarm);
 				break;
 			case 9:
 				vc->vc_report_mouse = on_off ? 1 : 0;
 				break;
 			case 25:		/* Cursor on/off */
 				vc->vc_deccm = on_off;
 				break;
 			case 1000:
 				vc->vc_report_mouse = on_off ? 2 : 0;
 				break;
 			}
 		} else {
 			switch(vc->vc_par[i]) {	/* ANSI modes set/reset */
 			case 3:			/* Monitor (display ctrls) */
 				vc->vc_disp_ctrl = on_off;
 				break;
 			case 4:			/* Insert Mode on/off */
 				vc->vc_decim = on_off;
 				break;
 			case 20:		/* Lf, Enter == CrLf/Lf */
 				if (on_off)
 					set_kbd(vc, lnm);
 				else
 					clr_kbd(vc, lnm);
 				break;
 			}
 		}
 }
 /* console_sem is held */
 static void setterm_command(struct vc_data *vc)
 {
 	switch(vc->vc_par[0]) {
 		case 1:	/* set color for underline mode */
 			if (vc->vc_can_do_color &&
 					vc->vc_par[1] < 16) {
 				vc->vc_ulcolor = color_table[vc->vc_par[1]];
 				if (vc->vc_underline)
 					update_attr(vc);
 			}
 			break;
 		case 2:	/* set color for half intensity mode */
 			if (vc->vc_can_do_color &&
 					vc->vc_par[1] < 16) {
 				vc->vc_halfcolor = color_table[vc->vc_par[1]];
 				if (vc->vc_intensity == 0)
 					update_attr(vc);
 			}
 			break;
 		case 8:	/* store colors as defaults */
 			vc->vc_def_color = vc->vc_attr;
 			if (vc->vc_hi_font_mask == 0x100)
 				vc->vc_def_color >>= 1;
 			default_attr(vc);
 			update_attr(vc);
 			break;
 		case 9:	/* set blanking interval */
 			blankinterval = ((vc->vc_par[1] < 60) ? vc->vc_par[1] : 60) * 60 * HZ;
 			poke_blanked_console();
 			break;
 		case 10: /* set bell frequency in Hz */
 			if (vc->vc_npar >= 1)
 				vc->vc_bell_pitch = vc->vc_par[1];
 			else
 				vc->vc_bell_pitch = DEFAULT_BELL_PITCH;
 			break;
 		case 11: /* set bell duration in msec */
 			if (vc->vc_npar >= 1)
 				vc->vc_bell_duration = (vc->vc_par[1] < 2000) ?
 					vc->vc_par[1] * HZ / 1000 : 0;
 			else
 				vc->vc_bell_duration = DEFAULT_BELL_DURATION;
 			break;
 		case 12: /* bring specified console to the front */
 			if (vc->vc_par[1] >= 1 && vc_cons_allocated(vc->vc_par[1] - 1))
 				set_console(vc->vc_par[1] - 1);
 			break;
 		case 13: /* unblank the screen */
 			poke_blanked_console();
 			break;
 		case 14: /* set vesa powerdown interval */
 			vesa_off_interval = ((vc->vc_par[1] < 60) ? vc->vc_par[1] : 60) * 60 * HZ;
 			break;
 		case 15: /* activate the previous console */
 			set_console(last_console);
 			break;
 	}
 }
 /* console_sem is held */
 static void csi_at(struct vc_data *vc, unsigned int nr)
 {
 	if (nr > vc->vc_cols - vc->vc_x)
 		nr = vc->vc_cols - vc->vc_x;
 	else if (!nr)
 		nr = 1;
 	insert_char(vc, nr);
 }
 /* console_sem is held */
 static void csi_L(struct vc_data *vc, unsigned int nr)
 {
 	if (nr > vc->vc_rows - vc->vc_y)
 		nr = vc->vc_rows - vc->vc_y;
 	else if (!nr)
 		nr = 1;
 	scrdown(vc, vc->vc_y, vc->vc_bottom, nr);
 	vc->vc_need_wrap = 0;
 }
 /* console_sem is held */
 static void csi_P(struct vc_data *vc, unsigned int nr)
 {
 	if (nr > vc->vc_cols - vc->vc_x)
 		nr = vc->vc_cols - vc->vc_x;
 	else if (!nr)
 		nr = 1;
 	delete_char(vc, nr);
 }
 /* console_sem is held */
 static void csi_M(struct vc_data *vc, unsigned int nr)
 {
 	if (nr > vc->vc_rows - vc->vc_y)
 		nr = vc->vc_rows - vc->vc_y;
 	else if (!nr)
 		nr=1;
 	scrup(vc, vc->vc_y, vc->vc_bottom, nr);
 	vc->vc_need_wrap = 0;
 }
 /* console_sem is held (except via vc_init->reset_terminal */
 static void save_cur(struct vc_data *vc)
 {
 	vc->vc_saved_x		= vc->vc_x;
 	vc->vc_saved_y		= vc->vc_y;
 	vc->vc_s_intensity	= vc->vc_intensity;
 	vc->vc_s_italic         = vc->vc_italic;
 	vc->vc_s_underline	= vc->vc_underline;
 	vc->vc_s_blink		= vc->vc_blink;
 	vc->vc_s_reverse	= vc->vc_reverse;
 	vc->vc_s_charset	= vc->vc_charset;
 	vc->vc_s_color		= vc->vc_color;
 	vc->vc_saved_G0		= vc->vc_G0_charset;
 	vc->vc_saved_G1		= vc->vc_G1_charset;
 }
 /* console_sem is held */
 static void restore_cur(struct vc_data *vc)
 {
 	gotoxy(vc, vc->vc_saved_x, vc->vc_saved_y);
 	vc->vc_intensity	= vc->vc_s_intensity;
 	vc->vc_italic		= vc->vc_s_italic;
 	vc->vc_underline	= vc->vc_s_underline;
 	vc->vc_blink		= vc->vc_s_blink;
 	vc->vc_reverse		= vc->vc_s_reverse;
 	vc->vc_charset		= vc->vc_s_charset;
 	vc->vc_color		= vc->vc_s_color;
 	vc->vc_G0_charset	= vc->vc_saved_G0;
 	vc->vc_G1_charset	= vc->vc_saved_G1;
 	vc->vc_translate	= set_translate(vc->vc_charset ? vc->vc_G1_charset : vc->vc_G0_charset, vc);
 	update_attr(vc);
 	vc->vc_need_wrap = 0;
 }
 enum { ESnormal, ESesc, ESsquare, ESgetpars, ESgotpars, ESfunckey,
 	EShash, ESsetG0, ESsetG1, ESpercent, ESignore, ESnonstd,
 	ESpalette };
 /* console_sem is held (except via vc_init()) */
 static void reset_terminal(struct vc_data *vc, int do_clear)
 {
 	vc->vc_top		= 0;
 	vc->vc_bottom		= vc->vc_rows;
 	vc->vc_state		= ESnormal;
 	vc->vc_ques		= 0;
 	vc->vc_translate	= set_translate(LAT1_MAP, vc);
 	vc->vc_G0_charset	= LAT1_MAP;
 	vc->vc_G1_charset	= GRAF_MAP;
 	vc->vc_charset		= 0;
 	vc->vc_need_wrap	= 0;
 	vc->vc_report_mouse	= 0;
 	vc->vc_utf              = default_utf8;
 	vc->vc_utf_count	= 0;
 	vc->vc_disp_ctrl	= 0;
 	vc->vc_toggle_meta	= 0;
 	vc->vc_decscnm		= 0;
 	vc->vc_decom		= 0;
 	vc->vc_decawm		= 1;
 	vc->vc_deccm		= 1;
 	vc->vc_decim		= 0;
 	set_kbd(vc, decarm);
 	clr_kbd(vc, decckm);
 	clr_kbd(vc, kbdapplic);
 	clr_kbd(vc, lnm);
 	kbd_table[vc->vc_num].lockstate = 0;
 	kbd_table[vc->vc_num].slockstate = 0;
 	kbd_table[vc->vc_num].ledmode = LED_SHOW_FLAGS;
 	kbd_table[vc->vc_num].ledflagstate = kbd_table[vc->vc_num].default_ledflagstate;
 	/* do not do set_leds here because this causes an endless tasklet loop
 	   when the keyboard hasn't been initialized yet */
 	vc->vc_cursor_type = CUR_DEFAULT;
 	vc->vc_complement_mask = vc->vc_s_complement_mask;
 	default_attr(vc);
 	update_attr(vc);
 	vc->vc_tab_stop[0]	= 0x01010100;
 	vc->vc_tab_stop[1]	=
 	vc->vc_tab_stop[2]	=
 	vc->vc_tab_stop[3]	=
 	vc->vc_tab_stop[4]	= 0x01010101;
 	vc->vc_bell_pitch = DEFAULT_BELL_PITCH;
 	vc->vc_bell_duration = DEFAULT_BELL_DURATION;
 	gotoxy(vc, 0, 0);
 	save_cur(vc);
 	if (do_clear)
 	    csi_J(vc, 2);
 }
 /* console_sem is held */
 static void do_con_trol(struct tty_struct *tty, struct vc_data *vc, int c)
 {
 	/*
 	 *  Control characters can be used in the _middle_
 	 *  of an escape sequence.
 	 */
 	switch (c) {
 	case 0:
 		return;
 	case 7:
 		if (vc->vc_bell_duration)
 			kd_mksound(vc->vc_bell_pitch, vc->vc_bell_duration);
 		return;
 	case 8:
 		bs(vc);
 		return;
 	case 9:
 		vc->vc_pos -= (vc->vc_x << 1);
 		while (vc->vc_x < vc->vc_cols - 1) {
 			vc->vc_x++;
 			if (vc->vc_tab_stop[vc->vc_x >> 5] & (1 << (vc->vc_x & 31)))
 				break;
 		}
 		vc->vc_pos += (vc->vc_x << 1);
 		return;
 	case 10: case 11: case 12:
 		lf(vc);
 		if (!is_kbd(vc, lnm))
 			return;
 	case 13:
 		cr(vc);
 		return;
 	case 14:
 		vc->vc_charset = 1;
 		vc->vc_translate = set_translate(vc->vc_G1_charset, vc);
 		vc->vc_disp_ctrl = 1;
 		return;
 	case 15:
 		vc->vc_charset = 0;
 		vc->vc_translate = set_translate(vc->vc_G0_charset, vc);
 		vc->vc_disp_ctrl = 0;
 		return;
 	case 24: case 26:
 		vc->vc_state = ESnormal;
 		return;
 	case 27:
 		vc->vc_state = ESesc;
 		return;
 	case 127:
 		del(vc);
 		return;
 	case 128+27:
 		vc->vc_state = ESsquare;
 		return;
 	}
 	switch(vc->vc_state) {
 	case ESesc:
 		vc->vc_state = ESnormal;
 		switch (c) {
 		case '[':
 			vc->vc_state = ESsquare;
 			return;
 		case ']':
 			vc->vc_state = ESnonstd;
 			return;
 		case '%':
 			vc->vc_state = ESpercent;
 			return;
 		case 'E':
 			cr(vc);
 			lf(vc);
 			return;
 		case 'M':
 			ri(vc);
 			return;
 		case 'D':
 			lf(vc);
 			return;
 		case 'H':
 			vc->vc_tab_stop[vc->vc_x >> 5] |= (1 << (vc->vc_x & 31));
 			return;
 		case 'Z':
 			respond_ID(tty);
 			return;
 		case '7':
 			save_cur(vc);
 			return;
 		case '8':
 			restore_cur(vc);
 			return;
 		case '(':
 			vc->vc_state = ESsetG0;
 			return;
 		case ')':
 			vc->vc_state = ESsetG1;
 			return;
 		case '#':
 			vc->vc_state = EShash;
 			return;
 		case 'c':
 			reset_terminal(vc, 1);
 			return;
 		case '>':  /* Numeric keypad */
 			clr_kbd(vc, kbdapplic);
 			return;
 		case '=':  /* Appl. keypad */
 			set_kbd(vc, kbdapplic);
 			return;
 		}
 		return;
 	case ESnonstd:
 		if (c=='P') {   /* palette escape sequence */
 			for (vc->vc_npar = 0; vc->vc_npar < NPAR; vc->vc_npar++)
 				vc->vc_par[vc->vc_npar] = 0;
 			vc->vc_npar = 0;
 			vc->vc_state = ESpalette;
 			return;
 		} else if (c=='R') {   /* reset palette */
 			reset_palette(vc);
 			vc->vc_state = ESnormal;
 		} else
 			vc->vc_state = ESnormal;
 		return;
 	case ESpalette:
 		if ( (c>='0'&&c<='9') || (c>='A'&&c<='F') || (c>='a'&&c<='f') ) {
 			vc->vc_par[vc->vc_npar++] = (c > '9' ? (c & 0xDF) - 'A' + 10 : c - '0');
 			if (vc->vc_npar == 7) {
 				int i = vc->vc_par[0] * 3, j = 1;
 				vc->vc_palette[i] = 16 * vc->vc_par[j++];
 				vc->vc_palette[i++] += vc->vc_par[j++];
 				vc->vc_palette[i] = 16 * vc->vc_par[j++];
 				vc->vc_palette[i++] += vc->vc_par[j++];
 				vc->vc_palette[i] = 16 * vc->vc_par[j++];
 				vc->vc_palette[i] += vc->vc_par[j];
 				set_palette(vc);
 				vc->vc_state = ESnormal;
 			}
 		} else
 			vc->vc_state = ESnormal;
 		return;
 	case ESsquare:
 		for (vc->vc_npar = 0; vc->vc_npar < NPAR; vc->vc_npar++)
 			vc->vc_par[vc->vc_npar] = 0;
 		vc->vc_npar = 0;
 		vc->vc_state = ESgetpars;
 		if (c == '[') { /* Function key */
 			vc->vc_state=ESfunckey;
 			return;
 		}
 		vc->vc_ques = (c == '?');
 		if (vc->vc_ques)
 			return;
 	case ESgetpars:
 		if (c == ';' && vc->vc_npar < NPAR - 1) {
 			vc->vc_npar++;
 			return;
 		} else if (c>='0' && c<='9') {
 			vc->vc_par[vc->vc_npar] *= 10;
 			vc->vc_par[vc->vc_npar] += c - '0';
 			return;
 		} else
 			vc->vc_state = ESgotpars;
 	case ESgotpars:
 		vc->vc_state = ESnormal;
 		switch(c) {
 		case 'h':
 			set_mode(vc, 1);
 			return;
 		case 'l':
 			set_mode(vc, 0);
 			return;
 		case 'c':
 			if (vc->vc_ques) {
 				if (vc->vc_par[0])
 					vc->vc_cursor_type = vc->vc_par[0] | (vc->vc_par[1] << 8) | (vc->vc_par[2] << 16);
 				else
 					vc->vc_cursor_type = CUR_DEFAULT;
 				return;
 			}
 			break;
 		case 'm':
 			if (vc->vc_ques) {
 				clear_selection();
 				if (vc->vc_par[0])
 					vc->vc_complement_mask = vc->vc_par[0] << 8 | vc->vc_par[1];
 				else
 					vc->vc_complement_mask = vc->vc_s_complement_mask;
 				return;
 			}
 			break;
 		case 'n':
 			if (!vc->vc_ques) {
 				if (vc->vc_par[0] == 5)
 					status_report(tty);
 				else if (vc->vc_par[0] == 6)
 					cursor_report(vc, tty);
 			}
 			return;
 		}
 		if (vc->vc_ques) {
 			vc->vc_ques = 0;
 			return;
 		}
 		switch(c) {
 		case 'G': case '`':
 			if (vc->vc_par[0])
 				vc->vc_par[0]--;
 			gotoxy(vc, vc->vc_par[0], vc->vc_y);
 			return;
 		case 'A':
 			if (!vc->vc_par[0])
 				vc->vc_par[0]++;
 			gotoxy(vc, vc->vc_x, vc->vc_y - vc->vc_par[0]);
 			return;
 		case 'B': case 'e':
 			if (!vc->vc_par[0])
 				vc->vc_par[0]++;
 			gotoxy(vc, vc->vc_x, vc->vc_y + vc->vc_par[0]);
 			return;
 		case 'C': case 'a':
 			if (!vc->vc_par[0])
 				vc->vc_par[0]++;
 			gotoxy(vc, vc->vc_x + vc->vc_par[0], vc->vc_y);
 			return;
 		case 'D':
 			if (!vc->vc_par[0])
 				vc->vc_par[0]++;
 			gotoxy(vc, vc->vc_x - vc->vc_par[0], vc->vc_y);
 			return;
 		case 'E':
 			if (!vc->vc_par[0])
 				vc->vc_par[0]++;
 			gotoxy(vc, 0, vc->vc_y + vc->vc_par[0]);
 			return;
 		case 'F':
 			if (!vc->vc_par[0])
 				vc->vc_par[0]++;
 			gotoxy(vc, 0, vc->vc_y - vc->vc_par[0]);
 			return;
 		case 'd':
 			if (vc->vc_par[0])
 				vc->vc_par[0]--;
 			gotoxay(vc, vc->vc_x ,vc->vc_par[0]);
 			return;
 		case 'H': case 'f':
 			if (vc->vc_par[0])
 				vc->vc_par[0]--;
 			if (vc->vc_par[1])
 				vc->vc_par[1]--;
 			gotoxay(vc, vc->vc_par[1], vc->vc_par[0]);
 			return;
 		case 'J':
 			csi_J(vc, vc->vc_par[0]);
 			return;
 		case 'K':
 			csi_K(vc, vc->vc_par[0]);
 			return;
 		case 'L':
 			csi_L(vc, vc->vc_par[0]);
 			return;
 		case 'M':
 			csi_M(vc, vc->vc_par[0]);
 			return;
 		case 'P':
 			csi_P(vc, vc->vc_par[0]);
 			return;
 		case 'c':
 			if (!vc->vc_par[0])
 				respond_ID(tty);
 			return;
 		case 'g':
 			if (!vc->vc_par[0])
 				vc->vc_tab_stop[vc->vc_x >> 5] &= ~(1 << (vc->vc_x & 31));
 			else if (vc->vc_par[0] == 3) {
 				vc->vc_tab_stop[0] =
 					vc->vc_tab_stop[1] =
 					vc->vc_tab_stop[2] =
 					vc->vc_tab_stop[3] =
 					vc->vc_tab_stop[4] = 0;
 			}
 			return;
 		case 'm':
 			csi_m(vc);
 			return;
 		case 'q': /* DECLL - but only 3 leds */
 			/* map 0,1,2,3 to 0,1,2,4 */
 			if (vc->vc_par[0] < 4)
 				setledstate(kbd_table + vc->vc_num,
 					    (vc->vc_par[0] < 3) ? vc->vc_par[0] : 4);
 			return;
 		case 'r':
 			if (!vc->vc_par[0])
 				vc->vc_par[0]++;
 			if (!vc->vc_par[1])
 				vc->vc_par[1] = vc->vc_rows;
 			/* Minimum allowed region is 2 lines */
 			if (vc->vc_par[0] < vc->vc_par[1] &&
 			    vc->vc_par[1] <= vc->vc_rows) {
 				vc->vc_top = vc->vc_par[0] - 1;
 				vc->vc_bottom = vc->vc_par[1];
 				gotoxay(vc, 0, 0);
 			}
 			return;
 		case 's':
 			save_cur(vc);
 			return;
 		case 'u':
 			restore_cur(vc);
 			return;
 		case 'X':
 			csi_X(vc, vc->vc_par[0]);
 			return;
 		case '@':
 			csi_at(vc, vc->vc_par[0]);
 			return;
 		case ']': /* setterm functions */
 			setterm_command(vc);
 			return;
 		}
 		return;
 	case ESpercent:
 		vc->vc_state = ESnormal;
 		switch (c) {
 		case '@':  /* defined in ISO 2022 */
 			vc->vc_utf = 0;
 			return;
 		case 'G':  /* prelim official escape code */
 		case '8':  /* retained for compatibility */
 			vc->vc_utf = 1;
 			return;
 		}
 		return;
 	case ESfunckey:
 		vc->vc_state = ESnormal;
 		return;
 	case EShash:
 		vc->vc_state = ESnormal;
 		if (c == '8') {
 			/* DEC screen alignment test. kludge :-) */
 			vc->vc_video_erase_char =
 				(vc->vc_video_erase_char & 0xff00) | 'E';
 			csi_J(vc, 2);
 			vc->vc_video_erase_char =
 				(vc->vc_video_erase_char & 0xff00) | ' ';
 			do_update_region(vc, vc->vc_origin, vc->vc_screenbuf_size / 2);
 		}
 		return;
 	case ESsetG0:
 		if (c == '0')
 			vc->vc_G0_charset = GRAF_MAP;
 		else if (c == 'B')
 			vc->vc_G0_charset = LAT1_MAP;
 		else if (c == 'U')
 			vc->vc_G0_charset = IBMPC_MAP;
 		else if (c == 'K')
 			vc->vc_G0_charset = USER_MAP;
 		if (vc->vc_charset == 0)
 			vc->vc_translate = set_translate(vc->vc_G0_charset, vc);
 		vc->vc_state = ESnormal;
 		return;
 	case ESsetG1:
 		if (c == '0')
 			vc->vc_G1_charset = GRAF_MAP;
 		else if (c == 'B')
 			vc->vc_G1_charset = LAT1_MAP;
 		else if (c == 'U')
 			vc->vc_G1_charset = IBMPC_MAP;
 		else if (c == 'K')
 			vc->vc_G1_charset = USER_MAP;
 		if (vc->vc_charset == 1)
 			vc->vc_translate = set_translate(vc->vc_G1_charset, vc);
 		vc->vc_state = ESnormal;
 		return;
 	default:
 		vc->vc_state = ESnormal;
 	}
 }
 /* This is a temporary buffer used to prepare a tty console write
  * so that we can easily avoid touching user space while holding the
  * console spinlock.  It is allocated in con_init and is shared by
  * this code and the vc_screen read/write tty calls.
  *
  * We have to allocate this statically in the kernel data section
  * since console_init (and thus con_init) are called before any
  * kernel memory allocation is available.
  */
 char con_buf[CON_BUF_SIZE];
 DEFINE_MUTEX(con_buf_mtx);
 /* is_double_width() is based on the wcwidth() implementation by
  * Markus Kuhn -- 2007-05-26 (Unicode 5.0)
  * Latest version: http://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c
  */
 struct interval {
 	uint32_t first;
 	uint32_t last;
 };
 static int bisearch(uint32_t ucs, const struct interval *table, int max)
 {
 	int min = 0;
 	int mid;
 	if (ucs < table[0].first || ucs > table[max].last)
 		return 0;
 	while (max >= min) {
 		mid = (min + max) / 2;
 		if (ucs > table[mid].last)
 			min = mid + 1;
 		else if (ucs < table[mid].first)
 			max = mid - 1;
 		else
 			return 1;
 	}
 	return 0;
 }
 static int is_double_width(uint32_t ucs)
 {
 	static const struct interval double_width[] = {
 		{ 0x1100, 0x115F }, { 0x2329, 0x232A }, { 0x2E80, 0x303E },
 		{ 0x3040, 0xA4CF }, { 0xAC00, 0xD7A3 }, { 0xF900, 0xFAFF },
 		{ 0xFE10, 0xFE19 }, { 0xFE30, 0xFE6F }, { 0xFF00, 0xFF60 },
 		{ 0xFFE0, 0xFFE6 }, { 0x20000, 0x2FFFD }, { 0x30000, 0x3FFFD }
 	};
 	return bisearch(ucs, double_width, ARRAY_SIZE(double_width) - 1);
 }
 /* acquires console_sem */
 static int do_con_write(struct tty_struct *tty, const unsigned char *buf, int count)
 {
 #ifdef VT_BUF_VRAM_ONLY
 #define FLUSH do { } while(0);
 #else
 #define FLUSH if (draw_x >= 0) { \
 	vc->vc_sw->con_putcs(vc, (u16 *)draw_from, (u16 *)draw_to - (u16 *)draw_from, vc->vc_y, draw_x); \
 	draw_x = -1; \
 	}
 #endif
 	int c, tc, ok, n = 0, draw_x = -1;
 	unsigned int currcons;
 	unsigned long draw_from = 0, draw_to = 0;
 	struct vc_data *vc;
 	unsigned char vc_attr;
 	uint8_t rescan;
 	uint8_t inverse;
 	uint8_t width;
 	u16 himask, charmask;
 	const unsigned char *orig_buf = NULL;
 	int orig_count;
 	if (in_interrupt())
 		return count;
 	might_sleep();
 	acquire_console_sem();
 	vc = tty->driver_data;
 	if (vc == NULL) {
 		printk(KERN_ERR "vt: argh, driver_data is NULL !\n");
 		release_console_sem();
 		return 0;
 	}
 	currcons = vc->vc_num;
 	if (!vc_cons_allocated(currcons)) {
 	    /* could this happen? */
 	    static int error = 0;
 	    if (!error) {
 		error = 1;
 		printk("con_write: tty %d not allocated\n", currcons+1);
 	    }
 	    release_console_sem();
 	    return 0;
 	}
 	release_console_sem();
 	orig_buf = buf;
 	orig_count = count;
 	/* At this point 'buf' is guaranteed to be a kernel buffer
 	 * and therefore no access to userspace (and therefore sleeping)
 	 * will be needed.  The con_buf_mtx serializes all tty based
 	 * console rendering and vcs write/read operations.  We hold
 	 * the console spinlock during the entire write.
 	 */
 	acquire_console_sem();
 	vc = tty->driver_data;
 	if (vc == NULL) {
 		printk(KERN_ERR "vt: argh, driver_data _became_ NULL !\n");
 		release_console_sem();
 		goto out;
 	}
 	himask = vc->vc_hi_font_mask;
 	charmask = himask ? 0x1ff : 0xff;
 	/* undraw cursor first */
 	if (IS_FG(vc))
 		hide_cursor(vc);
 	while (!tty->stopped && count) {
 		int orig = *buf;
 		c = orig;
 		buf++;
 		n++;
 		count--;
 		rescan = 0;
 		inverse = 0;
 		width = 1;
 		/* Do no translation at all in control states */
 		if (vc->vc_state != ESnormal) {
 			tc = c;
 		} else if (vc->vc_utf && !vc->vc_disp_ctrl) {
 		    /* Combine UTF-8 into Unicode in vc_utf_char.
 		     * vc_utf_count is the number of continuation bytes still
 		     * expected to arrive.
 		     * vc_npar is the number of continuation bytes arrived so
 		     * far
 		     */
 rescan_last_byte:
 		    if ((c & 0xc0) == 0x80) {
 			/* Continuation byte received */
 			static const uint32_t utf8_length_changes[] = { 0x0000007f, 0x000007ff, 0x0000ffff, 0x001fffff, 0x03ffffff, 0x7fffffff };
 			if (vc->vc_utf_count) {
 			    vc->vc_utf_char = (vc->vc_utf_char << 6) | (c & 0x3f);
 			    vc->vc_npar++;
 			    if (--vc->vc_utf_count) {
 				/* Still need some bytes */
 				continue;
 			    }
 			    /* Got a whole character */
 			    c = vc->vc_utf_char;
 			    /* Reject overlong sequences */
 			    if (c <= utf8_length_changes[vc->vc_npar - 1] ||
 					c > utf8_length_changes[vc->vc_npar])
 				c = 0xfffd;
 			} else {
 			    /* Unexpected continuation byte */
 			    vc->vc_utf_count = 0;
 			    c = 0xfffd;
 			}
 		    } else {
 			/* Single ASCII byte or first byte of a sequence received */
 			if (vc->vc_utf_count) {
 			    /* Continuation byte expected */
 			    rescan = 1;
 			    vc->vc_utf_count = 0;
 			    c = 0xfffd;
 			} else if (c > 0x7f) {
 			    /* First byte of a multibyte sequence received */
 			    vc->vc_npar = 0;
 			    if ((c & 0xe0) == 0xc0) {
 				vc->vc_utf_count = 1;
 				vc->vc_utf_char = (c & 0x1f);
 			    } else if ((c & 0xf0) == 0xe0) {
 				vc->vc_utf_count = 2;
 				vc->vc_utf_char = (c & 0x0f);
 			    } else if ((c & 0xf8) == 0xf0) {
 				vc->vc_utf_count = 3;
 				vc->vc_utf_char = (c & 0x07);
 			    } else if ((c & 0xfc) == 0xf8) {
 				vc->vc_utf_count = 4;
 				vc->vc_utf_char = (c & 0x03);
 			    } else if ((c & 0xfe) == 0xfc) {
 				vc->vc_utf_count = 5;
 				vc->vc_utf_char = (c & 0x01);
 			    } else {
 				/* 254 and 255 are invalid */
 				c = 0xfffd;
 			    }
 			    if (vc->vc_utf_count) {
 				/* Still need some bytes */
 				continue;
 			    }
 			}
 			/* Nothing to do if an ASCII byte was received */
 		    }
 		    /* End of UTF-8 decoding. */
 		    /* c is the received character, or U+FFFD for invalid sequences. */
 		    /* Replace invalid Unicode code points with U+FFFD too */
 		    if ((c >= 0xd800 && c <= 0xdfff) || c == 0xfffe || c == 0xffff)
 			c = 0xfffd;
 		    tc = c;
 		} else {	/* no utf or alternate charset mode */
 		    tc = vc->vc_translate[vc->vc_toggle_meta ? (c | 0x80) : c];
 		}
                 /* If the original code was a control character we
                  * only allow a glyph to be displayed if the code is
                  * not normally used (such as for cursor movement) or
                  * if the disp_ctrl mode has been explicitly enabled.
                  * Certain characters (as given by the CTRL_ALWAYS
                  * bitmap) are always displayed as control characters,
                  * as the console would be pretty useless without
                  * them; to display an arbitrary font position use the
                  * direct-to-font zone in UTF-8 mode.
                  */
                 ok = tc && (c >= 32 ||
 			    !(vc->vc_disp_ctrl ? (CTRL_ALWAYS >> c) & 1 :
 				  vc->vc_utf || ((CTRL_ACTION >> c) & 1)))
 			&& (c != 127 || vc->vc_disp_ctrl)
 			&& (c != 128+27);
 		if (vc->vc_state == ESnormal && ok) {
 			if (vc->vc_utf && !vc->vc_disp_ctrl) {
 				if (is_double_width(c))
 					width = 2;
 			}
 			/* Now try to find out how to display it */
 			tc = conv_uni_to_pc(vc, tc);
 			if (tc & ~charmask) {
 				if (tc == -1 || tc == -2) {
 				    continue; /* nothing to display */
 				}
 				/* Glyph not found */
 				if ((!(vc->vc_utf && !vc->vc_disp_ctrl) || c < 128) && !(c & ~charmask)) {
 				    /* In legacy mode use the glyph we get by a 1:1 mapping.
 				       This would make absolutely no sense with Unicode in mind,
 				       but do this for ASCII characters since a font may lack
 				       Unicode mapping info and we don't want to end up with
 				       having question marks only. */
 				    tc = c;
 				} else {
 				    /* Display U+FFFD. If it's not found, display an inverse question mark. */
 				    tc = conv_uni_to_pc(vc, 0xfffd);
 				    if (tc < 0) {
 					inverse = 1;
 					tc = conv_uni_to_pc(vc, '?');
 					if (tc < 0) tc = '?';
 				    }
 				}
 			}
 			if (!inverse) {
 				vc_attr = vc->vc_attr;
 			} else {
 				/* invert vc_attr */
 				if (!vc->vc_can_do_color) {
 					vc_attr = (vc->vc_attr) ^ 0x08;
 				} else if (vc->vc_hi_font_mask == 0x100) {
 					vc_attr = ((vc->vc_attr) & 0x11) | (((vc->vc_attr) & 0xe0) >> 4) | (((vc->vc_attr) & 0x0e) << 4);
 				} else {
 					vc_attr = ((vc->vc_attr) & 0x88) | (((vc->vc_attr) & 0x70) >> 4) | (((vc->vc_attr) & 0x07) << 4);
 				}
 				FLUSH
 			}
 			while (1) {
 				if (vc->vc_need_wrap || vc->vc_decim)
 					FLUSH
 				if (vc->vc_need_wrap) {
 					cr(vc);
 					lf(vc);
 				}
 				if (vc->vc_decim)
 					insert_char(vc, 1);
 				scr_writew(himask ?
 					     ((vc_attr << 8) & ~himask) + ((tc & 0x100) ? himask : 0) + (tc & 0xff) :
 					     (vc_attr << 8) + tc,
 					   (u16 *) vc->vc_pos);
 				if (DO_UPDATE(vc) && draw_x < 0) {
 					draw_x = vc->vc_x;
 					draw_from = vc->vc_pos;
 				}
 				if (vc->vc_x == vc->vc_cols - 1) {
 					vc->vc_need_wrap = vc->vc_decawm;
 					draw_to = vc->vc_pos + 2;
 				} else {
 					vc->vc_x++;
 					draw_to = (vc->vc_pos += 2);
 				}
 				if (!--width) break;
 				tc = conv_uni_to_pc(vc, ' '); /* A space is printed in the second column */
 				if (tc < 0) tc = ' ';
 			}
 			if (inverse) {
 				FLUSH
 			}
 			if (rescan) {
 				rescan = 0;
 				inverse = 0;
 				width = 1;
 				c = orig;
 				goto rescan_last_byte;
 			}
 			continue;
 		}
 		FLUSH
 		do_con_trol(tty, vc, orig);
 	}
 	FLUSH
 	console_conditional_schedule();
 	release_console_sem();
 out:
 	return n;
 #undef FLUSH
 }
 /*
  * This is the console switching callback.
  *
  * Doing console switching in a process context allows
  * us to do the switches asynchronously (needed when we want
  * to switch due to a keyboard interrupt).  Synchronization
  * with other console code and prevention of re-entrancy is
  * ensured with console_sem.
  */
 static void console_callback(struct work_struct *ignored)
 {
 	acquire_console_sem();
 	if (want_console >= 0) {
 		if (want_console != fg_console &&
 		    vc_cons_allocated(want_console)) {
 			hide_cursor(vc_cons[fg_console].d);
 			change_console(vc_cons[want_console].d);
 			/* we only changed when the console had already
 			   been allocated - a new console is not created
 			   in an interrupt routine */
 		}
 		want_console = -1;
 	}
 	if (do_poke_blanked_console) { /* do not unblank for a LED change */
 		do_poke_blanked_console = 0;
 		poke_blanked_console();
 	}
 	if (scrollback_delta) {
 		struct vc_data *vc = vc_cons[fg_console].d;
 		clear_selection();
 		if (vc->vc_mode == KD_TEXT)
 			vc->vc_sw->con_scrolldelta(vc, scrollback_delta);
 		scrollback_delta = 0;
 	}
 	if (blank_timer_expired) {
 		do_blank_screen(0);
 		blank_timer_expired = 0;
 	}
 	release_console_sem();
 }
 int set_console(int nr)
 {
 	struct vc_data *vc = vc_cons[fg_console].d;
 	if (!vc_cons_allocated(nr) || vt_dont_switch ||
 		(vc->vt_mode.mode == VT_AUTO && vc->vc_mode == KD_GRAPHICS)) {
 		/*
 		 * Console switch will fail in console_callback() or
 		 * change_console() so there is no point scheduling
 		 * the callback
 		 *
 		 * Existing set_console() users don't check the return
 		 * value so this shouldn't break anything
 		 */
 		return -EINVAL;
 	}
 	want_console = nr;
 	schedule_console_callback();
 	return 0;
 }
 struct tty_driver *console_driver;
 #ifdef CONFIG_VT_CONSOLE
 /*
  *	Console on virtual terminal
  *
  * The console must be locked when we get here.
  */
 static void vt_console_print(struct console *co, const char *b, unsigned count)
 {
 	struct vc_data *vc = vc_cons[fg_console].d;
 	unsigned char c;
 	static unsigned long printing;
 	const ushort *start;
 	ushort cnt = 0;
 	ushort myx;
 	/* console busy or not yet initialized */
 	if (!printable || test_and_set_bit(0, &printing))
 		return;
 	if (kmsg_redirect && vc_cons_allocated(kmsg_redirect - 1))
 		vc = vc_cons[kmsg_redirect - 1].d;
 	/* read `x' only after setting currcons properly (otherwise
 	   the `x' macro will read the x of the foreground console). */
 	myx = vc->vc_x;
 	if (!vc_cons_allocated(fg_console)) {
 		/* impossible */
 		/* printk("vt_console_print: tty %d not allocated ??\n", currcons+1); */
 		goto quit;
 	}
 	if (vc->vc_mode != KD_TEXT)
 		goto quit;
 	/* undraw cursor first */
 	if (IS_FG(vc))
 		hide_cursor(vc);
 	start = (ushort *)vc->vc_pos;
 	/* Contrived structure to try to emulate original need_wrap behaviour
 	 * Problems caused when we have need_wrap set on '\n' character */
 	while (count--) {
 		c = *b++;
 		if (c == 10 || c == 13 || c == 8 || vc->vc_need_wrap) {
 			if (cnt > 0) {
 				if (CON_IS_VISIBLE(vc))
 					vc->vc_sw->con_putcs(vc, start, cnt, vc->vc_y, vc->vc_x);
 				vc->vc_x += cnt;
 				if (vc->vc_need_wrap)
 					vc->vc_x--;
 				cnt = 0;
 			}
 			if (c == 8) {		/* backspace */
 				bs(vc);
 				start = (ushort *)vc->vc_pos;
 				myx = vc->vc_x;
 				continue;
 			}
 			if (c != 13)
 				lf(vc);
 			cr(vc);
 			start = (ushort *)vc->vc_pos;
 			myx = vc->vc_x;
 			if (c == 10 || c == 13)
 				continue;
 		}
 		scr_writew((vc->vc_attr << 8) + c, (unsigned short *)vc->vc_pos);
 		cnt++;
 		if (myx == vc->vc_cols - 1) {
 			vc->vc_need_wrap = 1;
 			continue;
 		}
 		vc->vc_pos += 2;
 		myx++;
 	}
 	if (cnt > 0) {
 		if (CON_IS_VISIBLE(vc))
 			vc->vc_sw->con_putcs(vc, start, cnt, vc->vc_y, vc->vc_x);
 		vc->vc_x += cnt;
 		if (vc->vc_x == vc->vc_cols) {
 			vc->vc_x--;
 			vc->vc_need_wrap = 1;
 		}
 	}
 	set_cursor(vc);
 quit:
 	clear_bit(0, &printing);
 }
 static struct tty_driver *vt_console_device(struct console *c, int *index)
 {
 	*index = c->index ? c->index-1 : fg_console;
 	return console_driver;
 }
 static struct console vt_console_driver = {
 	.name		= "tty",
 	.write		= vt_console_print,
 	.device		= vt_console_device,
 	.unblank	= unblank_screen,
 	.flags		= CON_PRINTBUFFER,
 	.index		= -1,
 };
 #endif
 /*
  *	Handling of Linux-specific VC ioctls
  */
 /*
  * Generally a bit racy with respect to console_sem().
  *
  * There are some functions which don't need it.
  *
  * There are some functions which can sleep for arbitrary periods
  * (paste_selection) but we don't need the lock there anyway.
  *
  * set_selection has locking, and definitely needs it
  */
 int tioclinux(struct tty_struct *tty, unsigned long arg)
 {
 	char type, data;
 	char __user *p = (char __user *)arg;
 	int lines;
 	int ret;
 	if (tty->driver->type != TTY_DRIVER_TYPE_CONSOLE)
 		return -EINVAL;
 	if (current->signal->tty != tty && !capable(CAP_SYS_ADMIN))
 		return -EPERM;
 	if (get_user(type, p))
 		return -EFAULT;
 	ret = 0;
 	switch (type)
 	{
 		case TIOCL_SETSEL:
 			acquire_console_sem();
 			ret = set_selection((struct tiocl_selection __user *)(p+1), tty);
 			release_console_sem();
 			break;
 		case TIOCL_PASTESEL:
 			ret = paste_selection(tty);
 			break;
 		case TIOCL_UNBLANKSCREEN:
 			acquire_console_sem();
 			unblank_screen();
 			release_console_sem();
 			break;
 		case TIOCL_SELLOADLUT:
 			ret = sel_loadlut(p);
 			break;
 		case TIOCL_GETSHIFTSTATE:
 	/*
 	 * Make it possible to react to Shift+Mousebutton.
 	 * Note that 'shift_state' is an undocumented
 	 * kernel-internal variable; programs not closely
 	 * related to the kernel should not use this.
 	 */
 	 		data = shift_state;
 			ret = __put_user(data, p);
 			break;
 		case TIOCL_GETMOUSEREPORTING:
 			data = mouse_reporting();
 			ret = __put_user(data, p);
 			break;
 		case TIOCL_SETVESABLANK:
 			ret = set_vesa_blanking(p);
 			break;
 		case TIOCL_GETKMSGREDIRECT:
 			data = kmsg_redirect;
 			ret = __put_user(data, p);
 			break;
 		case TIOCL_SETKMSGREDIRECT:
 			if (!capable(CAP_SYS_ADMIN)) {
 				ret = -EPERM;
 			} else {
 				if (get_user(data, p+1))
 					ret = -EFAULT;
 				else
 					kmsg_redirect = data;
 			}
 			break;
 		case TIOCL_GETFGCONSOLE:
 			ret = fg_console;
 			break;
 		case TIOCL_SCROLLCONSOLE:
 			if (get_user(lines, (s32 __user *)(p+4))) {
 				ret = -EFAULT;
 			} else {
 				scrollfront(vc_cons[fg_console].d, lines);
 				ret = 0;
 			}
 			break;
 		case TIOCL_BLANKSCREEN:	/* until explicitly unblanked, not only poked */
 			acquire_console_sem();
 			ignore_poke = 1;
 			do_blank_screen(0);
 			release_console_sem();
 			break;
 		case TIOCL_BLANKEDSCREEN:
 			ret = console_blanked;
 			break;
 		default:
 			ret = -EINVAL;
 			break;
 	}
 	return ret;
 }
 /*
  * /dev/ttyN handling
  */
 static int con_write(struct tty_struct *tty, const unsigned char *buf, int count)
 {
 	int	retval;
 	retval = do_con_write(tty, buf, count);
 	con_flush_chars(tty);
 	return retval;
 }
 static void con_put_char(struct tty_struct *tty, unsigned char ch)
 {
 	if (in_interrupt())
 		return;	/* n_r3964 calls put_char() from interrupt context */
 	do_con_write(tty, &ch, 1);
 }
 static int con_write_room(struct tty_struct *tty)
 {
 	if (tty->stopped)
 		return 0;
 	return 4096;		/* No limit, really; we're not buffering */
 }
 static int con_chars_in_buffer(struct tty_struct *tty)
 {
 	return 0;		/* we're not buffering */
 }
 /*
  * con_throttle and con_unthrottle are only used for
  * paste_selection(), which has to stuff in a large number of
  * characters...
  */
 static void con_throttle(struct tty_struct *tty)
 {
 }
 static void con_unthrottle(struct tty_struct *tty)
 {
 	struct vc_data *vc = tty->driver_data;
 	wake_up_interruptible(&vc->paste_wait);
 }
 /*
  * Turn the Scroll-Lock LED on when the tty is stopped
  */
 static void con_stop(struct tty_struct *tty)
 {
 	int console_num;
 	if (!tty)
 		return;
 	console_num = tty->index;
 	if (!vc_cons_allocated(console_num))
 		return;
 	set_vc_kbd_led(kbd_table + console_num, VC_SCROLLOCK);
 	set_leds();
 }
 /*
  * Turn the Scroll-Lock LED off when the console is started
  */
 static void con_start(struct tty_struct *tty)
 {
 	int console_num;
 	if (!tty)
 		return;
 	console_num = tty->index;
 	if (!vc_cons_allocated(console_num))
 		return;
 	clr_vc_kbd_led(kbd_table + console_num, VC_SCROLLOCK);
 	set_leds();
 }
 static void con_flush_chars(struct tty_struct *tty)
 {
 	struct vc_data *vc;
 	if (in_interrupt())	/* from flush_to_ldisc */
 		return;
 	/* if we race with con_close(), vt may be null */
 	acquire_console_sem();
 	vc = tty->driver_data;
 	if (vc)
 		set_cursor(vc);
 	release_console_sem();
 }
 /*
  * Allocate the console screen memory.
  */
 static int con_open(struct tty_struct *tty, struct file *filp)
 {
 	unsigned int currcons = tty->index;
 	int ret = 0;
 	acquire_console_sem();
 	if (tty->driver_data == NULL) {
 		ret = vc_allocate(currcons);
 		if (ret == 0) {
 			struct vc_data *vc = vc_cons[currcons].d;
 			tty->driver_data = vc;
 			vc->vc_tty = tty;
 			if (!tty->winsize.ws_row && !tty->winsize.ws_col) {
 				tty->winsize.ws_row = vc_cons[currcons].d->vc_rows;
 				tty->winsize.ws_col = vc_cons[currcons].d->vc_cols;
 			}
 			release_console_sem();
 			vcs_make_sysfs(tty);
 			return ret;
 		}
 	}
 	release_console_sem();
 	return ret;
 }
 /*
  * We take tty_mutex in here to prevent another thread from coming in via init_dev
  * and taking a ref against the tty while we're in the process of forgetting
  * about it and cleaning things up.
  *
  * This is because vcs_remove_sysfs() can sleep and will drop the BKL.
  */
 static void con_close(struct tty_struct *tty, struct file *filp)
 {
 	mutex_lock(&tty_mutex);
 	acquire_console_sem();
 	if (tty && tty->count == 1) {
 		struct vc_data *vc = tty->driver_data;
 		if (vc)
 			vc->vc_tty = NULL;
 		tty->driver_data = NULL;
 		release_console_sem();
 		vcs_remove_sysfs(tty);
 		mutex_unlock(&tty_mutex);
 		/*
 		 * tty_mutex is released, but we still hold BKL, so there is
 		 * still exclusion against init_dev()
 		 */
 		return;
 	}
 	release_console_sem();
 	mutex_unlock(&tty_mutex);
 }
 static int default_italic_color    = 2; // green (ASCII)
 static int default_underline_color = 3; // cyan (ASCII)
 module_param_named(italic, default_italic_color, int, S_IRUGO | S_IWUSR);
 module_param_named(underline, default_underline_color, int, S_IRUGO | S_IWUSR);
 static void vc_init(struct vc_data *vc, unsigned int rows,
 		    unsigned int cols, int do_clear)
 {
 	int j, k ;
 	vc->vc_cols = cols;
 	vc->vc_rows = rows;
 	vc->vc_size_row = cols << 1;
 	vc->vc_screenbuf_size = vc->vc_rows * vc->vc_size_row;
 	set_origin(vc);
 	vc->vc_pos = vc->vc_origin;
 	reset_vc(vc);
 	for (j=k=0; j<16; j++) {
 		vc->vc_palette[k++] = default_red[j] ;
 		vc->vc_palette[k++] = default_grn[j] ;
 		vc->vc_palette[k++] = default_blu[j] ;
 	}
 	vc->vc_def_color       = 0x07;   /* white */
 	vc->vc_ulcolor         = default_underline_color;
 	vc->vc_itcolor         = default_italic_color;
 	vc->vc_halfcolor       = 0x08;   /* grey */
 	init_waitqueue_head(&vc->paste_wait);
 	reset_terminal(vc, do_clear);
 }
 /*
  * This routine initializes console interrupts, and does nothing
  * else. If you want the screen to clear, call tty_write with
  * the appropriate escape-sequence.
  */
 static int __init con_init(void)
 {
 	const char *display_desc = NULL;
 	struct vc_data *vc;
 	unsigned int currcons = 0, i;
 	acquire_console_sem();
 	if (conswitchp)
 		display_desc = conswitchp->con_startup();
 	if (!display_desc) {
 		fg_console = 0;
 		release_console_sem();
 		return 0;
 	}
 	for (i = 0; i < MAX_NR_CON_DRIVER; i++) {
 		struct con_driver *con_driver = &registered_con_driver[i];
 		if (con_driver->con == NULL) {
 			con_driver->con = conswitchp;
 			con_driver->desc = display_desc;
 			con_driver->flag = CON_DRIVER_FLAG_INIT;
 			con_driver->first = 0;
 			con_driver->last = MAX_NR_CONSOLES - 1;
 			break;
 		}
 	}
 	for (i = 0; i < MAX_NR_CONSOLES; i++)
 		con_driver_map[i] = conswitchp;
 	if (blankinterval) {
 		blank_state = blank_normal_wait;
 		mod_timer(&console_timer, jiffies + blankinterval);
 	}
 	/*
 	 * kmalloc is not running yet - we use the bootmem allocator.
 	 */
 	for (currcons = 0; currcons < MIN_NR_CONSOLES; currcons++) {
 		vc_cons[currcons].d = vc = alloc_bootmem(sizeof(struct vc_data));
 		INIT_WORK(&vc_cons[currcons].SAK_work, vc_SAK);
 		visual_init(vc, currcons, 1);
 		vc->vc_screenbuf = (unsigned short *)alloc_bootmem(vc->vc_screenbuf_size);
 		vc->vc_kmalloced = 0;
 		vc_init(vc, vc->vc_rows, vc->vc_cols,
 			currcons || !vc->vc_sw->con_save_screen);
 	}
 	currcons = fg_console = 0;
 	master_display_fg = vc = vc_cons[currcons].d;
 	set_origin(vc);
 	save_screen(vc);
 	gotoxy(vc, vc->vc_x, vc->vc_y);
 	csi_J(vc, 0);
 	update_screen(vc);
 	printk("Console: %s %s %dx%d",
 		vc->vc_can_do_color ? "colour" : "mono",
 		display_desc, vc->vc_cols, vc->vc_rows);
 	printable = 1;
 	printk("\n");
 	release_console_sem();
 #ifdef CONFIG_VT_CONSOLE
 	register_console(&vt_console_driver);
 #endif
 	return 0;
 }
 console_initcall(con_init);
 static const struct tty_operations con_ops = {
 	.open = con_open,
 	.close = con_close,
 	.write = con_write,
 	.write_room = con_write_room,
 	.put_char = con_put_char,
 	.flush_chars = con_flush_chars,
 	.chars_in_buffer = con_chars_in_buffer,
 	.ioctl = vt_ioctl,
 	.stop = con_stop,
 	.start = con_start,
 	.throttle = con_throttle,
 	.unthrottle = con_unthrottle,
 };
 int __init vty_init(void)
 {
 	vcs_init();
 	console_driver = alloc_tty_driver(MAX_NR_CONSOLES);
 	if (!console_driver)
 		panic("Couldn't allocate console driver\n");
 	console_driver->owner = THIS_MODULE;
 	console_driver->name = "tty";
 	console_driver->name_base = 1;
 	console_driver->major = TTY_MAJOR;
 	console_driver->minor_start = 1;
 	console_driver->type = TTY_DRIVER_TYPE_CONSOLE;
 	console_driver->init_termios = tty_std_termios;
 	console_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_RESET_TERMIOS;
 	tty_set_operations(console_driver, &con_ops);
 	if (tty_register_driver(console_driver))
 		panic("Couldn't register console driver\n");
 	kbd_init();
 	console_map_init();
 #ifdef CONFIG_PROM_CONSOLE
 	prom_con_init();
 #endif
 #ifdef CONFIG_MDA_CONSOLE
 	mda_console_init();
 #endif
 	return 0;
 }
 #ifndef VT_SINGLE_DRIVER
 #include <linux/device.h>
 static struct class *vtconsole_class;
 static int bind_con_driver(const struct consw *csw, int first, int last,
 			   int deflt)
 {
 	struct module *owner = csw->owner;
 	const char *desc = NULL;
 	struct con_driver *con_driver;
 	int i, j = -1, k = -1, retval = -ENODEV;
 	if (!try_module_get(owner))
 		return -ENODEV;
 	acquire_console_sem();
 	/* check if driver is registered */
 	for (i = 0; i < MAX_NR_CON_DRIVER; i++) {
 		con_driver = &registered_con_driver[i];
 		if (con_driver->con == csw) {
 			desc = con_driver->desc;
 			retval = 0;
 			break;
 		}
 	}
 	if (retval)
 		goto err;
 	if (!(con_driver->flag & CON_DRIVER_FLAG_INIT)) {
 		csw->con_startup();
 		con_driver->flag |= CON_DRIVER_FLAG_INIT;
 	}
 	if (deflt) {
 		if (conswitchp)
 			module_put(conswitchp->owner);
 		__module_get(owner);
 		conswitchp = csw;
 	}
 	first = max(first, con_driver->first);
 	last = min(last, con_driver->last);
 	for (i = first; i <= last; i++) {
 		int old_was_color;
 		struct vc_data *vc = vc_cons[i].d;
 		if (con_driver_map[i])
 			module_put(con_driver_map[i]->owner);
 		__module_get(owner);
 		con_driver_map[i] = csw;
 		if (!vc || !vc->vc_sw)
 			continue;
 		j = i;
 		if (CON_IS_VISIBLE(vc)) {
 			k = i;
 			save_screen(vc);
 		}
 		old_was_color = vc->vc_can_do_color;
 		vc->vc_sw->con_deinit(vc);
 		vc->vc_origin = (unsigned long)vc->vc_screenbuf;
 		visual_init(vc, i, 0);
 		set_origin(vc);
 		update_attr(vc);
 		/* If the console changed between mono <-> color, then
 		 * the attributes in the screenbuf will be wrong.  The
 		 * following resets all attributes to something sane.
 		 */
 		if (old_was_color != vc->vc_can_do_color)
 			clear_buffer_attributes(vc);
 	}
 	printk("Console: switching ");
 	if (!deflt)
 		printk("consoles %d-%d ", first+1, last+1);
 	if (j >= 0) {
 		struct vc_data *vc = vc_cons[j].d;
 		printk("to %s %s %dx%d\n",
 		       vc->vc_can_do_color ? "colour" : "mono",
 		       desc, vc->vc_cols, vc->vc_rows);
 		if (k >= 0) {
 			vc = vc_cons[k].d;
 			update_screen(vc);
 		}
 	} else
 		printk("to %s\n", desc);
 	retval = 0;
 err:
 	release_console_sem();
 	module_put(owner);
 	return retval;
 };
 #ifdef CONFIG_VT_HW_CONSOLE_BINDING
 static int con_is_graphics(const struct consw *csw, int first, int last)
 {
 	int i, retval = 0;
 	for (i = first; i <= last; i++) {
 		struct vc_data *vc = vc_cons[i].d;
 		if (vc && vc->vc_mode == KD_GRAPHICS) {
 			retval = 1;
 			break;
 		}
 	}
 	return retval;
 }
 /**
  * unbind_con_driver - unbind a console driver
  * @csw: pointer to console driver to unregister
  * @first: first in range of consoles that @csw should be unbound from
  * @last: last in range of consoles that @csw should be unbound from
  * @deflt: should next bound console driver be default after @csw is unbound?
  *
  * To unbind a driver from all possible consoles, pass 0 as @first and
  * %MAX_NR_CONSOLES as @last.
  *
  * @deflt controls whether the console that ends up replacing @csw should be
  * the default console.
  *
  * RETURNS:
  * -ENODEV if @csw isn't a registered console driver or can't be unregistered
  * or 0 on success.
  */
 int unbind_con_driver(const struct consw *csw, int first, int last, int deflt)
 {
 	struct module *owner = csw->owner;
 	const struct consw *defcsw = NULL;
 	struct con_driver *con_driver = NULL, *con_back = NULL;
 	int i, retval = -ENODEV;
 	if (!try_module_get(owner))
 		return -ENODEV;
 	acquire_console_sem();
 	/* check if driver is registered and if it is unbindable */
 	for (i = 0; i < MAX_NR_CON_DRIVER; i++) {
 		con_driver = &registered_con_driver[i];
 		if (con_driver->con == csw &&
 		    con_driver->flag & CON_DRIVER_FLAG_MODULE) {
 			retval = 0;
 			break;
 		}
 	}
 	if (retval) {
 		release_console_sem();
 		goto err;
 	}
 	retval = -ENODEV;
 	/* check if backup driver exists */
 	for (i = 0; i < MAX_NR_CON_DRIVER; i++) {
 		con_back = &registered_con_driver[i];
 		if (con_back->con &&
 		    !(con_back->flag & CON_DRIVER_FLAG_MODULE)) {
 			defcsw = con_back->con;
 			retval = 0;
 			break;
 		}
 	}
 	if (retval) {
 		release_console_sem();
 		goto err;
 	}
 	if (!con_is_bound(csw)) {
 		release_console_sem();
 		goto err;
 	}
 	first = max(first, con_driver->first);
 	last = min(last, con_driver->last);
 	for (i = first; i <= last; i++) {
 		if (con_driver_map[i] == csw) {
 			module_put(csw->owner);
 			con_driver_map[i] = NULL;
 		}
 	}
 	if (!con_is_bound(defcsw)) {
 		const struct consw *defconsw = conswitchp;
 		defcsw->con_startup();
 		con_back->flag |= CON_DRIVER_FLAG_INIT;
 		/*
 		 * vgacon may change the default driver to point
 		 * to dummycon, we restore it here...
 		 */
 		conswitchp = defconsw;
 	}
 	if (!con_is_bound(csw))
 		con_driver->flag &= ~CON_DRIVER_FLAG_INIT;
 	release_console_sem();
 	/* ignore return value, binding should not fail */
 	bind_con_driver(defcsw, first, last, deflt);
 err:
 	module_put(owner);
 	return retval;
 }
 EXPORT_SYMBOL(unbind_con_driver);
 static int vt_bind(struct con_driver *con)
 {
 	const struct consw *defcsw = NULL, *csw = NULL;
 	int i, more = 1, first = -1, last = -1, deflt = 0;
  	if (!con->con || !(con->flag & CON_DRIVER_FLAG_MODULE) ||
 	    con_is_graphics(con->con, con->first, con->last))
 		goto err;
 	csw = con->con;
 	for (i = 0; i < MAX_NR_CON_DRIVER; i++) {
 		struct con_driver *con = &registered_con_driver[i];
 		if (con->con && !(con->flag & CON_DRIVER_FLAG_MODULE)) {
 			defcsw = con->con;
 			break;
 		}
 	}
 	if (!defcsw)
 		goto err;
 	while (more) {
 		more = 0;
 		for (i = con->first; i <= con->last; i++) {
 			if (con_driver_map[i] == defcsw) {
 				if (first == -1)
 					first = i;
 				last = i;
 				more = 1;
 			} else if (first != -1)
 				break;
 		}
 		if (first == 0 && last == MAX_NR_CONSOLES -1)
 			deflt = 1;
 		if (first != -1)
 			bind_con_driver(csw, first, last, deflt);
 		first = -1;
 		last = -1;
 		deflt = 0;
 	}
 err:
 	return 0;
 }
 static int vt_unbind(struct con_driver *con)
 {
 	const struct consw *csw = NULL;
 	int i, more = 1, first = -1, last = -1, deflt = 0;
  	if (!con->con || !(con->flag & CON_DRIVER_FLAG_MODULE) ||
 	    con_is_graphics(con->con, con->first, con->last))
 		goto err;
 	csw = con->con;
 	while (more) {
 		more = 0;
 		for (i = con->first; i <= con->last; i++) {
 			if (con_driver_map[i] == csw) {
 				if (first == -1)
 					first = i;
 				last = i;
 				more = 1;
 			} else if (first != -1)
 				break;
 		}
 		if (first == 0 && last == MAX_NR_CONSOLES -1)
 			deflt = 1;
 		if (first != -1)
 			unbind_con_driver(csw, first, last, deflt);
 		first = -1;
 		last = -1;
 		deflt = 0;
 	}
 err:
 	return 0;
 }
 #else
 static inline int vt_bind(struct con_driver *con)
 {
 	return 0;
 }
 static inline int vt_unbind(struct con_driver *con)
 {
 	return 0;
 }
 #endif /* CONFIG_VT_HW_CONSOLE_BINDING */
 static ssize_t store_bind(struct device *dev, struct device_attribute *attr,
 			  const char *buf, size_t count)
 {
 	struct con_driver *con = dev_get_drvdata(dev);
 	int bind = simple_strtoul(buf, NULL, 0);
 	if (bind)
 		vt_bind(con);
 	else
 		vt_unbind(con);
 	return count;
 }
 static ssize_t show_bind(struct device *dev, struct device_attribute *attr,
 			 char *buf)
 {
 	struct con_driver *con = dev_get_drvdata(dev);
 	int bind = con_is_bound(con->con);
 	return snprintf(buf, PAGE_SIZE, "%i\n", bind);
 }
 static ssize_t show_name(struct device *dev, struct device_attribute *attr,
 			 char *buf)
 {
 	struct con_driver *con = dev_get_drvdata(dev);
 	return snprintf(buf, PAGE_SIZE, "%s %s\n",
 			(con->flag & CON_DRIVER_FLAG_MODULE) ? "(M)" : "(S)",
 			 con->desc);
 }
 static struct device_attribute device_attrs[] = {
 	__ATTR(bind, S_IRUGO|S_IWUSR, show_bind, store_bind),
 	__ATTR(name, S_IRUGO, show_name, NULL),
 };
 static int vtconsole_init_device(struct con_driver *con)
 {
 	int i;
 	int error = 0;
 	con->flag |= CON_DRIVER_FLAG_ATTR;
 	dev_set_drvdata(con->dev, con);
 	for (i = 0; i < ARRAY_SIZE(device_attrs); i++) {
 		error = device_create_file(con->dev, &device_attrs[i]);
 		if (error)
 			break;
 	}
 	if (error) {
 		while (--i >= 0)
 			device_remove_file(con->dev, &device_attrs[i]);
 		con->flag &= ~CON_DRIVER_FLAG_ATTR;
 	}
 	return error;
 }
 static void vtconsole_deinit_device(struct con_driver *con)
 {
 	int i;
 	if (con->flag & CON_DRIVER_FLAG_ATTR) {
 		for (i = 0; i < ARRAY_SIZE(device_attrs); i++)
 			device_remove_file(con->dev, &device_attrs[i]);
 		con->flag &= ~CON_DRIVER_FLAG_ATTR;
 	}
 }
 /**
  * con_is_bound - checks if driver is bound to the console
  * @csw: console driver
  *
  * RETURNS: zero if unbound, nonzero if bound
  *
  * Drivers can call this and if zero, they should release
  * all resources allocated on con_startup()
  */
 int con_is_bound(const struct consw *csw)
 {
 	int i, bound = 0;
 	for (i = 0; i < MAX_NR_CONSOLES; i++) {
 		if (con_driver_map[i] == csw) {
 			bound = 1;
 			break;
 		}
 	}
 	return bound;
 }
 EXPORT_SYMBOL(con_is_bound);
 /**
  * register_con_driver - register console driver to console layer
  * @csw: console driver
  * @first: the first console to take over, minimum value is 0
  * @last: the last console to take over, maximum value is MAX_NR_CONSOLES -1
  *
  * DESCRIPTION: This function registers a console driver which can later
  * bind to a range of consoles specified by @first and @last. It will
  * also initialize the console driver by calling con_startup().
  */
 int register_con_driver(const struct consw *csw, int first, int last)
 {
 	struct module *owner = csw->owner;
 	struct con_driver *con_driver;
 	const char *desc;
 	int i, retval = 0;
 	if (!try_module_get(owner))
 		return -ENODEV;
 	acquire_console_sem();
 	for (i = 0; i < MAX_NR_CON_DRIVER; i++) {
 		con_driver = &registered_con_driver[i];
 		/* already registered */
 		if (con_driver->con == csw)
 			retval = -EINVAL;
 	}
 	if (retval)
 		goto err;
 	desc = csw->con_startup();
 	if (!desc)
 		goto err;
 	retval = -EINVAL;
 	for (i = 0; i < MAX_NR_CON_DRIVER; i++) {
 		con_driver = &registered_con_driver[i];
 		if (con_driver->con == NULL) {
 			con_driver->con = csw;
 			con_driver->desc = desc;
 			con_driver->node = i;
 			con_driver->flag = CON_DRIVER_FLAG_MODULE |
 			                   CON_DRIVER_FLAG_INIT;
 			con_driver->first = first;
 			con_driver->last = last;
 			retval = 0;
 			break;
 		}
 	}
 	if (retval)
 		goto err;
 	con_driver->dev = device_create(vtconsole_class, NULL,
 					MKDEV(0, con_driver->node),
 					"vtcon%i", con_driver->node);
 	if (IS_ERR(con_driver->dev)) {
 		printk(KERN_WARNING "Unable to create device for %s; "
 		       "errno = %ld\n", con_driver->desc,
 		       PTR_ERR(con_driver->dev));
 		con_driver->dev = NULL;
 	} else {
 		vtconsole_init_device(con_driver);
 	}
 err:
 	release_console_sem();
 	module_put(owner);
 	return retval;
 }
 EXPORT_SYMBOL(register_con_driver);
 /**
  * unregister_con_driver - unregister console driver from console layer
  * @csw: console driver
  *
  * DESCRIPTION: All drivers that registers to the console layer must
  * call this function upon exit, or if the console driver is in a state
  * where it won't be able to handle console services, such as the
  * framebuffer console without loaded framebuffer drivers.
  *
  * The driver must unbind first prior to unregistration.
  */
 int unregister_con_driver(const struct consw *csw)
 {
 	int i, retval = -ENODEV;
 	acquire_console_sem();
 	/* cannot unregister a bound driver */
 	if (con_is_bound(csw))
 		goto err;
 	for (i = 0; i < MAX_NR_CON_DRIVER; i++) {
 		struct con_driver *con_driver = &registered_con_driver[i];
 		if (con_driver->con == csw &&
 		    con_driver->flag & CON_DRIVER_FLAG_MODULE) {
 			vtconsole_deinit_device(con_driver);
 			device_destroy(vtconsole_class,
 				       MKDEV(0, con_driver->node));
 			con_driver->con = NULL;
 			con_driver->desc = NULL;
 			con_driver->dev = NULL;
 			con_driver->node = 0;
 			con_driver->flag = 0;
 			con_driver->first = 0;
 			con_driver->last = 0;
 			retval = 0;
 			break;
 		}
 	}
 err:
 	release_console_sem();
 	return retval;
 }
 EXPORT_SYMBOL(unregister_con_driver);
 /*
  *	If we support more console drivers, this function is used
  *	when a driver wants to take over some existing consoles
  *	and become default driver for newly opened ones.
  *
  *      take_over_console is basically a register followed by unbind
  */
 int take_over_console(const struct consw *csw, int first, int last, int deflt)
 {
 	int err;
 	err = register_con_driver(csw, first, last);
 	if (!err)
 		bind_con_driver(csw, first, last, deflt);
 	return err;
 }
 /*
  * give_up_console is a wrapper to unregister_con_driver. It will only
  * work if driver is fully unbound.
  */
 void give_up_console(const struct consw *csw)
 {
 	unregister_con_driver(csw);
 }
 static int __init vtconsole_class_init(void)
 {
 	int i;
 	vtconsole_class = class_create(THIS_MODULE, "vtconsole");
 	if (IS_ERR(vtconsole_class)) {
 		printk(KERN_WARNING "Unable to create vt console class; "
 		       "errno = %ld\n", PTR_ERR(vtconsole_class));
 		vtconsole_class = NULL;
 	}
 	/* Add system drivers to sysfs */
 	for (i = 0; i < MAX_NR_CON_DRIVER; i++) {
 		struct con_driver *con = &registered_con_driver[i];
 		if (con->con && !con->dev) {
 			con->dev = device_create(vtconsole_class, NULL,
 						 MKDEV(0, con->node),
 						 "vtcon%i", con->node);
 			if (IS_ERR(con->dev)) {
 				printk(KERN_WARNING "Unable to create "
 				       "device for %s; errno = %ld\n",
 				       con->desc, PTR_ERR(con->dev));
 				con->dev = NULL;
 			} else {
 				vtconsole_init_device(con);
 			}
 		}
 	}
 	return 0;
 }
 postcore_initcall(vtconsole_class_init);
 #endif
 /*
  *	Screen blanking
  */
 static int set_vesa_blanking(char __user *p)
 {
 	unsigned int mode;
 	if (get_user(mode, p + 1))
 		return -EFAULT;
 	vesa_blank_mode = (mode < 4) ? mode : 0;
 	return 0;
 }
 void do_blank_screen(int entering_gfx)
 {
 	struct vc_data *vc = vc_cons[fg_console].d;
 	int i;
 	WARN_CONSOLE_UNLOCKED();
 	if (console_blanked) {
 		if (blank_state == blank_vesa_wait) {
 			blank_state = blank_off;
 			vc->vc_sw->con_blank(vc, vesa_blank_mode + 1, 0);
 		}
 		return;
 	}
 	/* entering graphics mode? */
 	if (entering_gfx) {
 		hide_cursor(vc);
 		save_screen(vc);
 		vc->vc_sw->con_blank(vc, -1, 1);
 		console_blanked = fg_console + 1;
 		blank_state = blank_off;
 		set_origin(vc);
 		return;
 	}
 	if (blank_state != blank_normal_wait)
 		return;
 	blank_state = blank_off;
 	/* don't blank graphics */
 	if (vc->vc_mode != KD_TEXT) {
 		console_blanked = fg_console + 1;
 		return;
 	}
 	hide_cursor(vc);
 	del_timer_sync(&console_timer);
 	blank_timer_expired = 0;
 	save_screen(vc);
 	/* In case we need to reset origin, blanking hook returns 1 */
 	i = vc->vc_sw->con_blank(vc, vesa_off_interval ? 1 : (vesa_blank_mode + 1), 0);
 	console_blanked = fg_console + 1;
 	if (i)
 		set_origin(vc);
 	if (console_blank_hook && console_blank_hook(1))
 		return;
 	if (vesa_off_interval && vesa_blank_mode) {
 		blank_state = blank_vesa_wait;
 		mod_timer(&console_timer, jiffies + vesa_off_interval);
 	}
 }
 EXPORT_SYMBOL(do_blank_screen);
 /*
  * Called by timer as well as from vt_console_driver
  */
 void do_unblank_screen(int leaving_gfx)
 {
 	struct vc_data *vc;
 	/* This should now always be called from a "sane" (read: can schedule)
 	 * context for the sake of the low level drivers, except in the special
 	 * case of oops_in_progress
 	 */
 	if (!oops_in_progress)
 		might_sleep();
 	WARN_CONSOLE_UNLOCKED();
 	ignore_poke = 0;
 	if (!console_blanked)
 		return;
 	if (!vc_cons_allocated(fg_console)) {
 		/* impossible */
 		printk("unblank_screen: tty %d not allocated ??\n", fg_console+1);
 		return;
 	}
 	vc = vc_cons[fg_console].d;
 	if (vc->vc_mode != KD_TEXT)
 		return; /* but leave console_blanked != 0 */
 	if (blankinterval) {
 		mod_timer(&console_timer, jiffies + blankinterval);
 		blank_state = blank_normal_wait;
 	}
 	console_blanked = 0;
 	if (vc->vc_sw->con_blank(vc, 0, leaving_gfx))
 		/* Low-level driver cannot restore -> do it ourselves */
 		update_screen(vc);
 	if (console_blank_hook)
 		console_blank_hook(0);
 	set_palette(vc);
 	set_cursor(vc);
 }
 EXPORT_SYMBOL(do_unblank_screen);
 /*
  * This is called by the outside world to cause a forced unblank, mostly for
  * oopses. Currently, I just call do_unblank_screen(0), but we could eventually
  * call it with 1 as an argument and so force a mode restore... that may kill
  * X or at least garbage the screen but would also make the Oops visible...
  */
 void unblank_screen(void)
 {
 	do_unblank_screen(0);
 }
 /*
  * We defer the timer blanking to work queue so it can take the console mutex
  * (console operations can still happen at irq time, but only from printk which
  * has the console mutex. Not perfect yet, but better than no locking
  */
 static void blank_screen_t(unsigned long dummy)
 {
 	if (unlikely(!keventd_up())) {
 		mod_timer(&console_timer, jiffies + blankinterval);
 		return;
 	}
 	blank_timer_expired = 1;
 	schedule_work(&console_work);
 }
 void poke_blanked_console(void)
 {
 	WARN_CONSOLE_UNLOCKED();
 	/* Add this so we quickly catch whoever might call us in a non
 	 * safe context. Nowadays, unblank_screen() isn't to be called in
 	 * atomic contexts and is allowed to schedule (with the special case
 	 * of oops_in_progress, but that isn't of any concern for this
 	 * function. --BenH.
 	 */
 	might_sleep();
 	/* This isn't perfectly race free, but a race here would be mostly harmless,
 	 * at worse, we'll do a spurrious blank and it's unlikely
 	 */
 	del_timer(&console_timer);
 	blank_timer_expired = 0;
 	if (ignore_poke || !vc_cons[fg_console].d || vc_cons[fg_console].d->vc_mode == KD_GRAPHICS)
 		return;
 	if (console_blanked)
 		unblank_screen();
 	else if (blankinterval) {
 		mod_timer(&console_timer, jiffies + blankinterval);
 		blank_state = blank_normal_wait;
 	}
 }
 /*
  *	Palettes
  */
 static void set_palette(struct vc_data *vc)
 {
 	WARN_CONSOLE_UNLOCKED();
 	if (vc->vc_mode != KD_GRAPHICS)
 		vc->vc_sw->con_set_palette(vc, color_table);
 }
 static int set_get_cmap(unsigned char __user *arg, int set)
 {
     int i, j, k;
     WARN_CONSOLE_UNLOCKED();
     for (i = 0; i < 16; i++)
 	if (set) {
 	    get_user(default_red[i], arg++);
 	    get_user(default_grn[i], arg++);
 	    get_user(default_blu[i], arg++);
 	} else {
 	    put_user(default_red[i], arg++);
 	    put_user(default_grn[i], arg++);
 	    put_user(default_blu[i], arg++);
 	}
     if (set) {
 	for (i = 0; i < MAX_NR_CONSOLES; i++)
 	    if (vc_cons_allocated(i)) {
 		for (j = k = 0; j < 16; j++) {
 		    vc_cons[i].d->vc_palette[k++] = default_red[j];
 		    vc_cons[i].d->vc_palette[k++] = default_grn[j];
 		    vc_cons[i].d->vc_palette[k++] = default_blu[j];
 		}
 		set_palette(vc_cons[i].d);
 	    }
     }
     return 0;
 }
 /*
  * Load palette into the DAC registers. arg points to a colour
  * map, 3 bytes per colour, 16 colours, range from 0 to 255.
  */
 int con_set_cmap(unsigned char __user *arg)
 {
 	int rc;
 	acquire_console_sem();
 	rc = set_get_cmap (arg,1);
 	release_console_sem();
 	return rc;
 }
 int con_get_cmap(unsigned char __user *arg)
 {
 	int rc;
 	acquire_console_sem();
 	rc = set_get_cmap (arg,0);
 	release_console_sem();
 	return rc;
 }
 void reset_palette(struct vc_data *vc)
 {
 	int j, k;
 	for (j=k=0; j<16; j++) {
 		vc->vc_palette[k++] = default_red[j];
 		vc->vc_palette[k++] = default_grn[j];
 		vc->vc_palette[k++] = default_blu[j];
 	}
 	set_palette(vc);
 }
 /*
  *  Font switching
  *
  *  Currently we only support fonts up to 32 pixels wide, at a maximum height
  *  of 32 pixels. Userspace fontdata is stored with 32 bytes (shorts/ints,
  *  depending on width) reserved for each character which is kinda wasty, but
  *  this is done in order to maintain compatibility with the EGA/VGA fonts. It
  *  is upto the actual low-level console-driver convert data into its favorite
  *  format (maybe we should add a `fontoffset' field to the `display'
  *  structure so we won't have to convert the fontdata all the time.
  *  /Jes
  */
 #define max_font_size 65536
 static int con_font_get(struct vc_data *vc, struct console_font_op *op)
 {
 	struct console_font font;
 	int rc = -EINVAL;
 	int c;
 	if (vc->vc_mode != KD_TEXT)
 		return -EINVAL;
 	if (op->data) {
 		font.data = kmalloc(max_font_size, GFP_KERNEL);
 		if (!font.data)
 			return -ENOMEM;
 	} else
 		font.data = NULL;
 	acquire_console_sem();
 	if (vc->vc_sw->con_font_get)
 		rc = vc->vc_sw->con_font_get(vc, &font);
 	else
 		rc = -ENOSYS;
 	release_console_sem();
 	if (rc)
 		goto out;
 	c = (font.width+7)/8 * 32 * font.charcount;
 	if (op->data && font.charcount > op->charcount)
 		rc = -ENOSPC;
 	if (!(op->flags & KD_FONT_FLAG_OLD)) {
 		if (font.width > op->width || font.height > op->height)
 			rc = -ENOSPC;
 	} else {
 		if (font.width != 8)
 			rc = -EIO;
 		else if ((op->height && font.height > op->height) ||
 			 font.height > 32)
 			rc = -ENOSPC;
 	}
 	if (rc)
 		goto out;
 	op->height = font.height;
 	op->width = font.width;
 	op->charcount = font.charcount;
 	if (op->data && copy_to_user(op->data, font.data, c))
 		rc = -EFAULT;
 out:
 	kfree(font.data);
 	return rc;
 }
 static int con_font_set(struct vc_data *vc, struct console_font_op *op)
 {
 	struct console_font font;
 	int rc = -EINVAL;
 	int size;
 	if (vc->vc_mode != KD_TEXT)
 		return -EINVAL;
 	if (!op->data)
 		return -EINVAL;
 	if (op->charcount > 512)
 		return -EINVAL;
 	if (!op->height) {		/* Need to guess font height [compat] */
 		int h, i;
 		u8 __user *charmap = op->data;
 		u8 tmp;
 		/* If from KDFONTOP ioctl, don't allow things which can be done in userland,
 		   so that we can get rid of this soon */
 		if (!(op->flags & KD_FONT_FLAG_OLD))
 			return -EINVAL;
 		for (h = 32; h > 0; h--)
 			for (i = 0; i < op->charcount; i++) {
 				if (get_user(tmp, &charmap[32*i+h-1]))
 					return -EFAULT;
 				if (tmp)
 					goto nonzero;
 			}
 		return -EINVAL;
 	nonzero:
 		op->height = h;
 	}
 	if (op->width <= 0 || op->width > 32 || op->height > 32)
 		return -EINVAL;
 	size = (op->width+7)/8 * 32 * op->charcount;
 	if (size > max_font_size)
 		return -ENOSPC;
 	font.charcount = op->charcount;
 	font.height = op->height;
 	font.width = op->width;
 	font.data = kmalloc(size, GFP_KERNEL);
 	if (!font.data)
 		return -ENOMEM;
 	if (copy_from_user(font.data, op->data, size)) {
 		kfree(font.data);
 		return -EFAULT;
 	}
 	acquire_console_sem();
 	if (vc->vc_sw->con_font_set)
 		rc = vc->vc_sw->con_font_set(vc, &font, op->flags);
 	else
 		rc = -ENOSYS;
 	release_console_sem();
 	kfree(font.data);
 	return rc;
 }
 static int con_font_default(struct vc_data *vc, struct console_font_op *op)
 {
 	struct console_font font = {.width = op->width, .height = op->height};
 	char name[MAX_FONT_NAME];
 	char *s = name;
 	int rc;
 	if (vc->vc_mode != KD_TEXT)
 		return -EINVAL;
 	if (!op->data)
 		s = NULL;
 	else if (strncpy_from_user(name, op->data, MAX_FONT_NAME - 1) < 0)
 		return -EFAULT;
 	else
 		name[MAX_FONT_NAME - 1] = 0;
 	acquire_console_sem();
 	if (vc->vc_sw->con_font_default)
 		rc = vc->vc_sw->con_font_default(vc, &font, s);
 	else
 		rc = -ENOSYS;
 	release_console_sem();
 	if (!rc) {
 		op->width = font.width;
 		op->height = font.height;
 	}
 	return rc;
 }
 static int con_font_copy(struct vc_data *vc, struct console_font_op *op)
 {
 	int con = op->height;
 	int rc;
 	if (vc->vc_mode != KD_TEXT)
 		return -EINVAL;
 	acquire_console_sem();
 	if (!vc->vc_sw->con_font_copy)
 		rc = -ENOSYS;
 	else if (con < 0 || !vc_cons_allocated(con))
 		rc = -ENOTTY;
 	else if (con == vc->vc_num)	/* nothing to do */
 		rc = 0;
 	else
 		rc = vc->vc_sw->con_font_copy(vc, con);
 	release_console_sem();
 	return rc;
 }
 int con_font_op(struct vc_data *vc, struct console_font_op *op)
 {
 	switch (op->op) {
 	case KD_FONT_OP_SET:
 		return con_font_set(vc, op);
 	case KD_FONT_OP_GET:
 		return con_font_get(vc, op);
 	case KD_FONT_OP_SET_DEFAULT:
 		return con_font_default(vc, op);
 	case KD_FONT_OP_COPY:
 		return con_font_copy(vc, op);
 	}
 	return -ENOSYS;
 }
 /*
  *	Interface exported to selection and vcs.
  */
 /* used by selection */
 u16 screen_glyph(struct vc_data *vc, int offset)
 {
 	u16 w = scr_readw(screenpos(vc, offset, 1));
 	u16 c = w & 0xff;
 	if (w & vc->vc_hi_font_mask)
 		c |= 0x100;
 	return c;
 }
 /* used by vcs - note the word offset */
 unsigned short *screen_pos(struct vc_data *vc, int w_offset, int viewed)
 {
 	return screenpos(vc, 2 * w_offset, viewed);
 }
 void getconsxy(struct vc_data *vc, unsigned char *p)
 {
 	p[0] = vc->vc_x;
 	p[1] = vc->vc_y;
 }
 void putconsxy(struct vc_data *vc, unsigned char *p)
 {
 	hide_cursor(vc);
 	gotoxy(vc, p[0], p[1]);
 	set_cursor(vc);
 }
 u16 vcs_scr_readw(struct vc_data *vc, const u16 *org)
 {
 	if ((unsigned long)org == vc->vc_pos && softcursor_original != -1)
 		return softcursor_original;
 	return scr_readw(org);
 }
 void vcs_scr_writew(struct vc_data *vc, u16 val, u16 *org)
 {
 	scr_writew(val, org);
 	if ((unsigned long)org == vc->vc_pos) {
 		softcursor_original = -1;
 		add_softcursor(vc);
 	}
 }
 /*
  *	Visible symbols for modules
  */
 EXPORT_SYMBOL(color_table);
 EXPORT_SYMBOL(default_red);
 EXPORT_SYMBOL(default_grn);
 EXPORT_SYMBOL(default_blu);
 EXPORT_SYMBOL(update_region);
 EXPORT_SYMBOL(redraw_screen);
 EXPORT_SYMBOL(vc_resize);
 EXPORT_SYMBOL(vc_lock_resize);
 EXPORT_SYMBOL(fg_console);
 EXPORT_SYMBOL(console_blank_hook);
 EXPORT_SYMBOL(console_blanked);
 EXPORT_SYMBOL(vc_cons);
 #ifndef VT_SINGLE_DRIVER
 EXPORT_SYMBOL(take_over_console);
 EXPORT_SYMBOL(give_up_console);
 #endif

drivers/char/vt_ioctl.c

Diff comments View file @ 2e8ecb9

1	/*	1	/*
2	* linux/drivers/char/vt_ioctl.c	2	* linux/drivers/char/vt_ioctl.c
3	*	3	*
4	* Copyright (C) 1992 obz under the linux copyright	4	* Copyright (C) 1992 obz under the linux copyright
5	*	5	*
6	* Dynamic diacritical handling - aeb@cwi.nl - Dec 1993	6	* Dynamic diacritical handling - aeb@cwi.nl - Dec 1993
7	* Dynamic keymap and string allocation - aeb@cwi.nl - May 1994	7	* Dynamic keymap and string allocation - aeb@cwi.nl - May 1994
8	* Restrict VT switching via ioctl() - grif@cs.ucr.edu - Dec 1995	8	* Restrict VT switching via ioctl() - grif@cs.ucr.edu - Dec 1995
9	* Some code moved for less code duplication - Andi Kleen - Mar 1997	9	* Some code moved for less code duplication - Andi Kleen - Mar 1997
10	* Check put/get_user, cleanups - acme@conectiva.com.br - Jun 2001	10	* Check put/get_user, cleanups - acme@conectiva.com.br - Jun 2001
11	*/	11	*/
12		12
13	#include <linux/types.h>	13	#include <linux/types.h>
14	#include <linux/errno.h>	14	#include <linux/errno.h>
15	#include <linux/sched.h>	15	#include <linux/sched.h>
16	#include <linux/tty.h>	16	#include <linux/tty.h>
17	#include <linux/timer.h>	17	#include <linux/timer.h>
18	#include <linux/kernel.h>	18	#include <linux/kernel.h>
19	#include <linux/kd.h>	19	#include <linux/kd.h>
20	#include <linux/vt.h>	20	#include <linux/vt.h>
21	#include <linux/string.h>	21	#include <linux/string.h>
22	#include <linux/slab.h>	22	#include <linux/slab.h>
23	#include <linux/major.h>	23	#include <linux/major.h>
24	#include <linux/fs.h>	24	#include <linux/fs.h>
25	#include <linux/console.h>	25	#include <linux/console.h>
26	#include <linux/consolemap.h>	26	#include <linux/consolemap.h>
27	#include <linux/signal.h>	27	#include <linux/signal.h>
28	#include <linux/timex.h>	28	#include <linux/timex.h>
29		29
30	#include <asm/io.h>	30	#include <asm/io.h>
31	#include <asm/uaccess.h>	31	#include <asm/uaccess.h>
32		32
33	#include <linux/kbd_kern.h>	33	#include <linux/kbd_kern.h>
34	#include <linux/vt_kern.h>	34	#include <linux/vt_kern.h>
35	#include <linux/kbd_diacr.h>	35	#include <linux/kbd_diacr.h>
36	#include <linux/selection.h>	36	#include <linux/selection.h>
37		37
38	char vt_dont_switch;	38	char vt_dont_switch;
39	extern struct tty_driver *console_driver;	39	extern struct tty_driver *console_driver;
40		40
41	#define VT_IS_IN_USE(i) (console_driver->ttys[i] && console_driver->ttys[i]->count)	41	#define VT_IS_IN_USE(i) (console_driver->ttys[i] && console_driver->ttys[i]->count)
42	#define VT_BUSY(i) (VT_IS_IN_USE(i) \|\| i == fg_console \|\| vc_cons[i].d == sel_cons)	42	#define VT_BUSY(i) (VT_IS_IN_USE(i) \|\| i == fg_console \|\| vc_cons[i].d == sel_cons)
43		43
44	/*	44	/*
45	* Console (vt and kd) routines, as defined by USL SVR4 manual, and by	45	* Console (vt and kd) routines, as defined by USL SVR4 manual, and by
46	* experimentation and study of X386 SYSV handling.	46	* experimentation and study of X386 SYSV handling.
47	*	47	*
48	* One point of difference: SYSV vt's are /dev/vtX, which X >= 0, and	48	* One point of difference: SYSV vt's are /dev/vtX, which X >= 0, and
49	* /dev/console is a separate ttyp. Under Linux, /dev/tty0 is /dev/console,	49	* /dev/console is a separate ttyp. Under Linux, /dev/tty0 is /dev/console,
50	* and the vc start at /dev/ttyX, X >= 1. We maintain that here, so we will	50	* and the vc start at /dev/ttyX, X >= 1. We maintain that here, so we will
51	* always treat our set of vt as numbered 1..MAX_NR_CONSOLES (corresponding to	51	* always treat our set of vt as numbered 1..MAX_NR_CONSOLES (corresponding to
52	* ttys 0..MAX_NR_CONSOLES-1). Explicitly naming VT 0 is illegal, but using	52	* ttys 0..MAX_NR_CONSOLES-1). Explicitly naming VT 0 is illegal, but using
53	* /dev/tty0 (fg_console) as a target is legal, since an implicit aliasing	53	* /dev/tty0 (fg_console) as a target is legal, since an implicit aliasing
54	* to the current console is done by the main ioctl code.	54	* to the current console is done by the main ioctl code.
55	*/	55	*/
56		56
57	#ifdef CONFIG_X86	57	#ifdef CONFIG_X86
58	#include <linux/syscalls.h>	58	#include <linux/syscalls.h>
59	#endif	59	#endif
60		60
61	static void complete_change_console(struct vc_data *vc);	61	static void complete_change_console(struct vc_data *vc);
62		62
63	/*	63	/*
64	* these are the valid i/o ports we're allowed to change. they map all the	64	* these are the valid i/o ports we're allowed to change. they map all the
65	* video ports	65	* video ports
66	*/	66	*/
67	#define GPFIRST 0x3b4	67	#define GPFIRST 0x3b4
68	#define GPLAST 0x3df	68	#define GPLAST 0x3df
69	#define GPNUM (GPLAST - GPFIRST + 1)	69	#define GPNUM (GPLAST - GPFIRST + 1)
70		70
71	#define i (tmp.kb_index)	71	#define i (tmp.kb_index)
72	#define s (tmp.kb_table)	72	#define s (tmp.kb_table)
73	#define v (tmp.kb_value)	73	#define v (tmp.kb_value)
74	static inline int	74	static inline int
75	do_kdsk_ioctl(int cmd, struct kbentry __user user_kbe, int perm, struct kbd_struct kbd)	75	do_kdsk_ioctl(int cmd, struct kbentry __user user_kbe, int perm, struct kbd_struct kbd)
76	{	76	{
77	struct kbentry tmp;	77	struct kbentry tmp;
78	ushort *key_map, val, ov;	78	ushort *key_map, val, ov;
79		79
80	if (copy_from_user(&tmp, user_kbe, sizeof(struct kbentry)))	80	if (copy_from_user(&tmp, user_kbe, sizeof(struct kbentry)))
81	return -EFAULT;	81	return -EFAULT;
82		82
83	if (!capable(CAP_SYS_TTY_CONFIG))	83	if (!capable(CAP_SYS_TTY_CONFIG))
84	perm = 0;	84	perm = 0;
85		85
86	switch (cmd) {	86	switch (cmd) {
87	case KDGKBENT:	87	case KDGKBENT:
88	key_map = key_maps[s];	88	key_map = key_maps[s];
89	if (key_map) {	89	if (key_map) {
90	val = U(key_map[i]);	90	val = U(key_map[i]);
91	if (kbd->kbdmode != VC_UNICODE && KTYP(val) >= NR_TYPES)	91	if (kbd->kbdmode != VC_UNICODE && KTYP(val) >= NR_TYPES)
92	val = K_HOLE;	92	val = K_HOLE;
93	} else	93	} else
94	val = (i ? K_HOLE : K_NOSUCHMAP);	94	val = (i ? K_HOLE : K_NOSUCHMAP);
95	return put_user(val, &user_kbe->kb_value);	95	return put_user(val, &user_kbe->kb_value);
96	case KDSKBENT:	96	case KDSKBENT:
97	if (!perm)	97	if (!perm)
98	return -EPERM;	98	return -EPERM;
99	if (!i && v == K_NOSUCHMAP) {	99	if (!i && v == K_NOSUCHMAP) {
100	/* deallocate map */	100	/* deallocate map */
101	key_map = key_maps[s];	101	key_map = key_maps[s];
102	if (s && key_map) {	102	if (s && key_map) {
103	key_maps[s] = NULL;	103	key_maps[s] = NULL;
104	if (key_map[0] == U(K_ALLOCATED)) {	104	if (key_map[0] == U(K_ALLOCATED)) {
105	kfree(key_map);	105	kfree(key_map);
106	keymap_count--;	106	keymap_count--;
107	}	107	}
108	}	108	}
109	break;	109	break;
110	}	110	}
111		111
112	if (KTYP(v) < NR_TYPES) {	112	if (KTYP(v) < NR_TYPES) {
113	if (KVAL(v) > max_vals[KTYP(v)])	113	if (KVAL(v) > max_vals[KTYP(v)])
114	return -EINVAL;	114	return -EINVAL;
115	} else	115	} else
116	if (kbd->kbdmode != VC_UNICODE)	116	if (kbd->kbdmode != VC_UNICODE)
117	return -EINVAL;	117	return -EINVAL;
118		118
119	/* ++Geert: non-PC keyboards may generate keycode zero */	119	/* ++Geert: non-PC keyboards may generate keycode zero */
120	#if !defined(__mc68000__) && !defined(__powerpc__)	120	#if !defined(__mc68000__) && !defined(__powerpc__)
121	/* assignment to entry 0 only tests validity of args */	121	/* assignment to entry 0 only tests validity of args */
122	if (!i)	122	if (!i)
123	break;	123	break;
124	#endif	124	#endif
125		125
126	if (!(key_map = key_maps[s])) {	126	if (!(key_map = key_maps[s])) {
127	int j;	127	int j;
128		128
129	if (keymap_count >= MAX_NR_OF_USER_KEYMAPS &&	129	if (keymap_count >= MAX_NR_OF_USER_KEYMAPS &&
130	!capable(CAP_SYS_RESOURCE))	130	!capable(CAP_SYS_RESOURCE))
131	return -EPERM;	131	return -EPERM;
132		132
133	key_map = kmalloc(sizeof(plain_map),	133	key_map = kmalloc(sizeof(plain_map),
134	GFP_KERNEL);	134	GFP_KERNEL);
135	if (!key_map)	135	if (!key_map)
136	return -ENOMEM;	136	return -ENOMEM;
137	key_maps[s] = key_map;	137	key_maps[s] = key_map;
138	key_map[0] = U(K_ALLOCATED);	138	key_map[0] = U(K_ALLOCATED);
139	for (j = 1; j < NR_KEYS; j++)	139	for (j = 1; j < NR_KEYS; j++)
140	key_map[j] = U(K_HOLE);	140	key_map[j] = U(K_HOLE);
141	keymap_count++;	141	keymap_count++;
142	}	142	}
143	ov = U(key_map[i]);	143	ov = U(key_map[i]);
144	if (v == ov)	144	if (v == ov)
145	break; /* nothing to do */	145	break; /* nothing to do */
146	/*	146	/*
147	* Attention Key.	147	* Attention Key.
148	*/	148	*/
149	if (((ov == K_SAK) \|\| (v == K_SAK)) && !capable(CAP_SYS_ADMIN))	149	if (((ov == K_SAK) \|\| (v == K_SAK)) && !capable(CAP_SYS_ADMIN))
150	return -EPERM;	150	return -EPERM;
151	key_map[i] = U(v);	151	key_map[i] = U(v);
152	if (!s && (KTYP(ov) == KT_SHIFT \|\| KTYP(v) == KT_SHIFT))	152	if (!s && (KTYP(ov) == KT_SHIFT \|\| KTYP(v) == KT_SHIFT))
153	compute_shiftstate();	153	compute_shiftstate();
154	break;	154	break;
155	}	155	}
156	return 0;	156	return 0;
157	}	157	}
158	#undef i	158	#undef i
159	#undef s	159	#undef s
160	#undef v	160	#undef v
161		161
162	static inline int	162	static inline int
163	do_kbkeycode_ioctl(int cmd, struct kbkeycode __user *user_kbkc, int perm)	163	do_kbkeycode_ioctl(int cmd, struct kbkeycode __user *user_kbkc, int perm)
164	{	164	{
165	struct kbkeycode tmp;	165	struct kbkeycode tmp;
166	int kc = 0;	166	int kc = 0;
167		167
168	if (copy_from_user(&tmp, user_kbkc, sizeof(struct kbkeycode)))	168	if (copy_from_user(&tmp, user_kbkc, sizeof(struct kbkeycode)))
169	return -EFAULT;	169	return -EFAULT;
170	switch (cmd) {	170	switch (cmd) {
171	case KDGETKEYCODE:	171	case KDGETKEYCODE:
172	kc = getkeycode(tmp.scancode);	172	kc = getkeycode(tmp.scancode);
173	if (kc >= 0)	173	if (kc >= 0)
174	kc = put_user(kc, &user_kbkc->keycode);	174	kc = put_user(kc, &user_kbkc->keycode);
175	break;	175	break;
176	case KDSETKEYCODE:	176	case KDSETKEYCODE:
177	if (!perm)	177	if (!perm)
178	return -EPERM;	178	return -EPERM;
179	kc = setkeycode(tmp.scancode, tmp.keycode);	179	kc = setkeycode(tmp.scancode, tmp.keycode);
180	break;	180	break;
181	}	181	}
182	return kc;	182	return kc;
183	}	183	}
184		184
185	static inline int	185	static inline int
186	do_kdgkb_ioctl(int cmd, struct kbsentry __user *user_kdgkb, int perm)	186	do_kdgkb_ioctl(int cmd, struct kbsentry __user *user_kdgkb, int perm)
187	{	187	{
188	struct kbsentry *kbs;	188	struct kbsentry *kbs;
189	char *p;	189	char *p;
190	u_char *q;	190	u_char *q;
191	u_char __user *up;	191	u_char __user *up;
192	int sz;	192	int sz;
193	int delta;	193	int delta;
194	char first_free, fj, *fnw;	194	char first_free, fj, *fnw;
195	int i, j, k;	195	int i, j, k;
196	int ret;	196	int ret;
197		197
198	if (!capable(CAP_SYS_TTY_CONFIG))	198	if (!capable(CAP_SYS_TTY_CONFIG))
199	perm = 0;	199	perm = 0;
200		200
201	kbs = kmalloc(sizeof(*kbs), GFP_KERNEL);	201	kbs = kmalloc(sizeof(*kbs), GFP_KERNEL);
202	if (!kbs) {	202	if (!kbs) {
203	ret = -ENOMEM;	203	ret = -ENOMEM;
204	goto reterr;	204	goto reterr;
205	}	205	}
206		206
207	/* we mostly copy too much here (512bytes), but who cares ;) */	207	/* we mostly copy too much here (512bytes), but who cares ;) */
208	if (copy_from_user(kbs, user_kdgkb, sizeof(struct kbsentry))) {	208	if (copy_from_user(kbs, user_kdgkb, sizeof(struct kbsentry))) {
209	ret = -EFAULT;	209	ret = -EFAULT;
210	goto reterr;	210	goto reterr;
211	}	211	}
212	kbs->kb_string[sizeof(kbs->kb_string)-1] = '\0';	212	kbs->kb_string[sizeof(kbs->kb_string)-1] = '\0';
213	i = kbs->kb_func;	213	i = kbs->kb_func;
214		214
215	switch (cmd) {	215	switch (cmd) {
216	case KDGKBSENT:	216	case KDGKBSENT:
217	sz = sizeof(kbs->kb_string) - 1; /* sz should have been	217	sz = sizeof(kbs->kb_string) - 1; /* sz should have been
218	a struct member */	218	a struct member */
219	up = user_kdgkb->kb_string;	219	up = user_kdgkb->kb_string;
220	p = func_table[i];	220	p = func_table[i];
221	if(p)	221	if(p)
222	for ( ; *p && sz; p++, sz--)	222	for ( ; *p && sz; p++, sz--)
223	if (put_user(*p, up++)) {	223	if (put_user(*p, up++)) {
224	ret = -EFAULT;	224	ret = -EFAULT;
225	goto reterr;	225	goto reterr;
226	}	226	}
227	if (put_user('\0', up)) {	227	if (put_user('\0', up)) {
228	ret = -EFAULT;	228	ret = -EFAULT;
229	goto reterr;	229	goto reterr;
230	}	230	}
231	kfree(kbs);	231	kfree(kbs);
232	return ((p && *p) ? -EOVERFLOW : 0);	232	return ((p && *p) ? -EOVERFLOW : 0);
233	case KDSKBSENT:	233	case KDSKBSENT:
234	if (!perm) {	234	if (!perm) {
235	ret = -EPERM;	235	ret = -EPERM;
236	goto reterr;	236	goto reterr;
237	}	237	}
238		238
239	q = func_table[i];	239	q = func_table[i];
240	first_free = funcbufptr + (funcbufsize - funcbufleft);	240	first_free = funcbufptr + (funcbufsize - funcbufleft);
241	for (j = i+1; j < MAX_NR_FUNC && !func_table[j]; j++)	241	for (j = i+1; j < MAX_NR_FUNC && !func_table[j]; j++)
242	;	242	;
243	if (j < MAX_NR_FUNC)	243	if (j < MAX_NR_FUNC)
244	fj = func_table[j];	244	fj = func_table[j];
245	else	245	else
246	fj = first_free;	246	fj = first_free;
247		247
248	delta = (q ? -strlen(q) : 1) + strlen(kbs->kb_string);	248	delta = (q ? -strlen(q) : 1) + strlen(kbs->kb_string);
249	if (delta <= funcbufleft) { /* it fits in current buf */	249	if (delta <= funcbufleft) { /* it fits in current buf */
250	if (j < MAX_NR_FUNC) {	250	if (j < MAX_NR_FUNC) {
251	memmove(fj + delta, fj, first_free - fj);	251	memmove(fj + delta, fj, first_free - fj);
252	for (k = j; k < MAX_NR_FUNC; k++)	252	for (k = j; k < MAX_NR_FUNC; k++)
253	if (func_table[k])	253	if (func_table[k])
254	func_table[k] += delta;	254	func_table[k] += delta;
255	}	255	}
256	if (!q)	256	if (!q)
257	func_table[i] = fj;	257	func_table[i] = fj;
258	funcbufleft -= delta;	258	funcbufleft -= delta;
259	} else { /* allocate a larger buffer */	259	} else { /* allocate a larger buffer */
260	sz = 256;	260	sz = 256;
261	while (sz < funcbufsize - funcbufleft + delta)	261	while (sz < funcbufsize - funcbufleft + delta)
262	sz <<= 1;	262	sz <<= 1;
263	fnw = kmalloc(sz, GFP_KERNEL);	263	fnw = kmalloc(sz, GFP_KERNEL);
264	if(!fnw) {	264	if(!fnw) {
265	ret = -ENOMEM;	265	ret = -ENOMEM;
266	goto reterr;	266	goto reterr;
267	}	267	}
268		268
269	if (!q)	269	if (!q)
270	func_table[i] = fj;	270	func_table[i] = fj;
271	if (fj > funcbufptr)	271	if (fj > funcbufptr)
272	memmove(fnw, funcbufptr, fj - funcbufptr);	272	memmove(fnw, funcbufptr, fj - funcbufptr);
273	for (k = 0; k < j; k++)	273	for (k = 0; k < j; k++)
274	if (func_table[k])	274	if (func_table[k])
275	func_table[k] = fnw + (func_table[k] - funcbufptr);	275	func_table[k] = fnw + (func_table[k] - funcbufptr);
276		276
277	if (first_free > fj) {	277	if (first_free > fj) {
278	memmove(fnw + (fj - funcbufptr) + delta, fj, first_free - fj);	278	memmove(fnw + (fj - funcbufptr) + delta, fj, first_free - fj);
279	for (k = j; k < MAX_NR_FUNC; k++)	279	for (k = j; k < MAX_NR_FUNC; k++)
280	if (func_table[k])	280	if (func_table[k])
281	func_table[k] = fnw + (func_table[k] - funcbufptr) + delta;	281	func_table[k] = fnw + (func_table[k] - funcbufptr) + delta;
282	}	282	}
283	if (funcbufptr != func_buf)	283	if (funcbufptr != func_buf)
284	kfree(funcbufptr);	284	kfree(funcbufptr);
285	funcbufptr = fnw;	285	funcbufptr = fnw;
286	funcbufleft = funcbufleft - delta + sz - funcbufsize;	286	funcbufleft = funcbufleft - delta + sz - funcbufsize;
287	funcbufsize = sz;	287	funcbufsize = sz;
288	}	288	}
289	strcpy(func_table[i], kbs->kb_string);	289	strcpy(func_table[i], kbs->kb_string);
290	break;	290	break;
291	}	291	}
292	ret = 0;	292	ret = 0;
293	reterr:	293	reterr:
294	kfree(kbs);	294	kfree(kbs);
295	return ret;	295	return ret;
296	}	296	}
297		297
298	static inline int	298	static inline int
299	do_fontx_ioctl(int cmd, struct consolefontdesc __user user_cfd, int perm, struct console_font_op op)	299	do_fontx_ioctl(int cmd, struct consolefontdesc __user user_cfd, int perm, struct console_font_op op)
300	{	300	{
301	struct consolefontdesc cfdarg;	301	struct consolefontdesc cfdarg;
302	int i;	302	int i;
303		303
304	if (copy_from_user(&cfdarg, user_cfd, sizeof(struct consolefontdesc)))	304	if (copy_from_user(&cfdarg, user_cfd, sizeof(struct consolefontdesc)))
305	return -EFAULT;	305	return -EFAULT;
306		306
307	switch (cmd) {	307	switch (cmd) {
308	case PIO_FONTX:	308	case PIO_FONTX:
309	if (!perm)	309	if (!perm)
310	return -EPERM;	310	return -EPERM;
311	op->op = KD_FONT_OP_SET;	311	op->op = KD_FONT_OP_SET;
312	op->flags = KD_FONT_FLAG_OLD;	312	op->flags = KD_FONT_FLAG_OLD;
313	op->width = 8;	313	op->width = 8;
314	op->height = cfdarg.charheight;	314	op->height = cfdarg.charheight;
315	op->charcount = cfdarg.charcount;	315	op->charcount = cfdarg.charcount;
316	op->data = cfdarg.chardata;	316	op->data = cfdarg.chardata;
317	return con_font_op(vc_cons[fg_console].d, op);	317	return con_font_op(vc_cons[fg_console].d, op);
318	case GIO_FONTX: {	318	case GIO_FONTX: {
319	op->op = KD_FONT_OP_GET;	319	op->op = KD_FONT_OP_GET;
320	op->flags = KD_FONT_FLAG_OLD;	320	op->flags = KD_FONT_FLAG_OLD;
321	op->width = 8;	321	op->width = 8;
322	op->height = cfdarg.charheight;	322	op->height = cfdarg.charheight;
323	op->charcount = cfdarg.charcount;	323	op->charcount = cfdarg.charcount;
324	op->data = cfdarg.chardata;	324	op->data = cfdarg.chardata;
325	i = con_font_op(vc_cons[fg_console].d, op);	325	i = con_font_op(vc_cons[fg_console].d, op);
326	if (i)	326	if (i)
327	return i;	327	return i;
328	cfdarg.charheight = op->height;	328	cfdarg.charheight = op->height;
329	cfdarg.charcount = op->charcount;	329	cfdarg.charcount = op->charcount;
330	if (copy_to_user(user_cfd, &cfdarg, sizeof(struct consolefontdesc)))	330	if (copy_to_user(user_cfd, &cfdarg, sizeof(struct consolefontdesc)))
331	return -EFAULT;	331	return -EFAULT;
332	return 0;	332	return 0;
333	}	333	}
334	}	334	}
335	return -EINVAL;	335	return -EINVAL;
336	}	336	}
337		337
338	static inline int	338	static inline int
339	do_unimap_ioctl(int cmd, struct unimapdesc __user user_ud, int perm, struct vc_data vc)	339	do_unimap_ioctl(int cmd, struct unimapdesc __user user_ud, int perm, struct vc_data vc)
340	{	340	{
341	struct unimapdesc tmp;	341	struct unimapdesc tmp;
342		342
343	if (copy_from_user(&tmp, user_ud, sizeof tmp))	343	if (copy_from_user(&tmp, user_ud, sizeof tmp))
344	return -EFAULT;	344	return -EFAULT;
345	if (tmp.entries)	345	if (tmp.entries)
346	if (!access_ok(VERIFY_WRITE, tmp.entries,	346	if (!access_ok(VERIFY_WRITE, tmp.entries,
347	tmp.entry_ct*sizeof(struct unipair)))	347	tmp.entry_ct*sizeof(struct unipair)))
348	return -EFAULT;	348	return -EFAULT;
349	switch (cmd) {	349	switch (cmd) {
350	case PIO_UNIMAP:	350	case PIO_UNIMAP:
351	if (!perm)	351	if (!perm)
352	return -EPERM;	352	return -EPERM;
353	return con_set_unimap(vc, tmp.entry_ct, tmp.entries);	353	return con_set_unimap(vc, tmp.entry_ct, tmp.entries);
354	case GIO_UNIMAP:	354	case GIO_UNIMAP:
355	if (!perm && fg_console != vc->vc_num)	355	if (!perm && fg_console != vc->vc_num)
356	return -EPERM;	356	return -EPERM;
357	return con_get_unimap(vc, tmp.entry_ct, &(user_ud->entry_ct), tmp.entries);	357	return con_get_unimap(vc, tmp.entry_ct, &(user_ud->entry_ct), tmp.entries);
358	}	358	}
359	return 0;	359	return 0;
360	}	360	}
361		361
362	/*	362	/*
363	* We handle the console-specific ioctl's here. We allow the	363	* We handle the console-specific ioctl's here. We allow the
364	* capability to modify any console, not just the fg_console.	364	* capability to modify any console, not just the fg_console.
365	*/	365	*/
366	int vt_ioctl(struct tty_struct tty, struct file file,	366	int vt_ioctl(struct tty_struct tty, struct file file,
367	unsigned int cmd, unsigned long arg)	367	unsigned int cmd, unsigned long arg)
368	{	368	{
369	struct vc_data vc = (struct vc_data )tty->driver_data;	369	struct vc_data vc = (struct vc_data )tty->driver_data;
370	struct console_font_op op; /* used in multiple places here */	370	struct console_font_op op; /* used in multiple places here */
371	struct kbd_struct * kbd;	371	struct kbd_struct * kbd;
372	unsigned int console;	372	unsigned int console;
373	unsigned char ucval;	373	unsigned char ucval;
374	void __user up = (void __user )arg;	374	void __user up = (void __user )arg;
375	int i, perm;	375	int i, perm;
376		376
377	console = vc->vc_num;	377	console = vc->vc_num;
378		378
379	if (!vc_cons_allocated(console)) /* impossible? */	379	if (!vc_cons_allocated(console)) /* impossible? */
380	return -ENOIOCTLCMD;	380	return -ENOIOCTLCMD;
381		381
382	/*	382	/*
383	* To have permissions to do most of the vt ioctls, we either have	383	* To have permissions to do most of the vt ioctls, we either have
384	* to be the owner of the tty, or have CAP_SYS_TTY_CONFIG.	384	* to be the owner of the tty, or have CAP_SYS_TTY_CONFIG.
385	*/	385	*/
386	perm = 0;	386	perm = 0;
387	if (current->signal->tty == tty \|\| capable(CAP_SYS_TTY_CONFIG))	387	if (current->signal->tty == tty \|\| capable(CAP_SYS_TTY_CONFIG))
388	perm = 1;	388	perm = 1;
389		389
390	kbd = kbd_table + console;	390	kbd = kbd_table + console;
391	switch (cmd) {	391	switch (cmd) {
392	case KIOCSOUND:	392	case KIOCSOUND:
393	if (!perm)	393	if (!perm)
394	return -EPERM;	394	return -EPERM;
395	if (arg)	395	if (arg)
396	arg = CLOCK_TICK_RATE / arg;	396	arg = CLOCK_TICK_RATE / arg;
397	kd_mksound(arg, 0);	397	kd_mksound(arg, 0);
398	return 0;	398	return 0;
399		399
400	case KDMKTONE:	400	case KDMKTONE:
401	if (!perm)	401	if (!perm)
402	return -EPERM;	402	return -EPERM;
403	{	403	{
404	unsigned int ticks, count;	404	unsigned int ticks, count;
405		405
406	/*	406	/*
407	* Generate the tone for the appropriate number of ticks.	407	* Generate the tone for the appropriate number of ticks.
408	* If the time is zero, turn off sound ourselves.	408	* If the time is zero, turn off sound ourselves.
409	*/	409	*/
410	ticks = HZ * ((arg >> 16) & 0xffff) / 1000;	410	ticks = HZ * ((arg >> 16) & 0xffff) / 1000;
411	count = ticks ? (arg & 0xffff) : 0;	411	count = ticks ? (arg & 0xffff) : 0;
412	if (count)	412	if (count)
413	count = CLOCK_TICK_RATE / count;	413	count = CLOCK_TICK_RATE / count;
414	kd_mksound(count, ticks);	414	kd_mksound(count, ticks);
415	return 0;	415	return 0;
416	}	416	}
417		417
418	case KDGKBTYPE:	418	case KDGKBTYPE:
419	/*	419	/*
420	* this is naive.	420	* this is naive.
421	*/	421	*/
422	ucval = KB_101;	422	ucval = KB_101;
423	goto setchar;	423	goto setchar;
424		424
425	/*	425	/*
426	* These cannot be implemented on any machine that implements	426	* These cannot be implemented on any machine that implements
427	* ioperm() in user level (such as Alpha PCs) or not at all.	427	* ioperm() in user level (such as Alpha PCs) or not at all.
428	*	428	*
429	* XXX: you should never use these, just call ioperm directly..	429	* XXX: you should never use these, just call ioperm directly..
430	*/	430	*/
431	#ifdef CONFIG_X86	431	#ifdef CONFIG_X86
432	case KDADDIO:	432	case KDADDIO:
433	case KDDELIO:	433	case KDDELIO:
434	/*	434	/*
435	* KDADDIO and KDDELIO may be able to add ports beyond what	435	* KDADDIO and KDDELIO may be able to add ports beyond what
436	* we reject here, but to be safe...	436	* we reject here, but to be safe...
437	*/	437	*/
438	if (arg < GPFIRST \|\| arg > GPLAST)	438	if (arg < GPFIRST \|\| arg > GPLAST)
439	return -EINVAL;	439	return -EINVAL;
440	return sys_ioperm(arg, 1, (cmd == KDADDIO)) ? -ENXIO : 0;	440	return sys_ioperm(arg, 1, (cmd == KDADDIO)) ? -ENXIO : 0;
441		441
442	case KDENABIO:	442	case KDENABIO:
443	case KDDISABIO:	443	case KDDISABIO:
444	return sys_ioperm(GPFIRST, GPNUM,	444	return sys_ioperm(GPFIRST, GPNUM,
445	(cmd == KDENABIO)) ? -ENXIO : 0;	445	(cmd == KDENABIO)) ? -ENXIO : 0;
446	#endif	446	#endif
447		447
448	/* Linux m68k/i386 interface for setting the keyboard delay/repeat rate */	448	/* Linux m68k/i386 interface for setting the keyboard delay/repeat rate */
449		449
450	case KDKBDREP:	450	case KDKBDREP:
451	{	451	{
452	struct kbd_repeat kbrep;	452	struct kbd_repeat kbrep;
453	int err;	453	int err;
454		454
455	if (!capable(CAP_SYS_TTY_CONFIG))	455	if (!capable(CAP_SYS_TTY_CONFIG))
456	return -EPERM;	456	return -EPERM;
457		457
458	if (copy_from_user(&kbrep, up, sizeof(struct kbd_repeat)))	458	if (copy_from_user(&kbrep, up, sizeof(struct kbd_repeat)))
459	return -EFAULT;	459	return -EFAULT;
460	err = kbd_rate(&kbrep);	460	err = kbd_rate(&kbrep);
461	if (err)	461	if (err)
462	return err;	462	return err;
463	if (copy_to_user(up, &kbrep, sizeof(struct kbd_repeat)))	463	if (copy_to_user(up, &kbrep, sizeof(struct kbd_repeat)))
464	return -EFAULT;	464	return -EFAULT;
465	return 0;	465	return 0;
466	}	466	}
467		467
468	case KDSETMODE:	468	case KDSETMODE:
469	/*	469	/*
470	* currently, setting the mode from KD_TEXT to KD_GRAPHICS	470	* currently, setting the mode from KD_TEXT to KD_GRAPHICS
471	* doesn't do a whole lot. i'm not sure if it should do any	471	* doesn't do a whole lot. i'm not sure if it should do any
472	* restoration of modes or what...	472	* restoration of modes or what...
473	*	473	*
474	* XXX It should at least call into the driver, fbdev's definitely	474	* XXX It should at least call into the driver, fbdev's definitely
475	* need to restore their engine state. --BenH	475	* need to restore their engine state. --BenH
476	*/	476	*/
477	if (!perm)	477	if (!perm)
478	return -EPERM;	478	return -EPERM;
479	switch (arg) {	479	switch (arg) {
480	case KD_GRAPHICS:	480	case KD_GRAPHICS:
481	break;	481	break;
482	case KD_TEXT0:	482	case KD_TEXT0:
483	case KD_TEXT1:	483	case KD_TEXT1:
484	arg = KD_TEXT;	484	arg = KD_TEXT;
485	case KD_TEXT:	485	case KD_TEXT:
486	break;	486	break;
487	default:	487	default:
488	return -EINVAL;	488	return -EINVAL;
489	}	489	}
490	if (vc->vc_mode == (unsigned char) arg)	490	if (vc->vc_mode == (unsigned char) arg)
491	return 0;	491	return 0;
492	vc->vc_mode = (unsigned char) arg;	492	vc->vc_mode = (unsigned char) arg;
493	if (console != fg_console)	493	if (console != fg_console)
494	return 0;	494	return 0;
495	/*	495	/*
496	* explicitly blank/unblank the screen if switching modes	496	* explicitly blank/unblank the screen if switching modes
497	*/	497	*/
498	acquire_console_sem();	498	acquire_console_sem();
499	if (arg == KD_TEXT)	499	if (arg == KD_TEXT)
500	do_unblank_screen(1);	500	do_unblank_screen(1);
501	else	501	else
502	do_blank_screen(1);	502	do_blank_screen(1);
503	release_console_sem();	503	release_console_sem();
504	return 0;	504	return 0;
505		505
506	case KDGETMODE:	506	case KDGETMODE:
507	ucval = vc->vc_mode;	507	ucval = vc->vc_mode;
508	goto setint;	508	goto setint;
509		509
510	case KDMAPDISP:	510	case KDMAPDISP:
511	case KDUNMAPDISP:	511	case KDUNMAPDISP:
512	/*	512	/*
513	* these work like a combination of mmap and KDENABIO.	513	* these work like a combination of mmap and KDENABIO.
514	* this could be easily finished.	514	* this could be easily finished.
515	*/	515	*/
516	return -EINVAL;	516	return -EINVAL;
517		517
518	case KDSKBMODE:	518	case KDSKBMODE:
519	if (!perm)	519	if (!perm)
520	return -EPERM;	520	return -EPERM;
521	switch(arg) {	521	switch(arg) {
522	case K_RAW:	522	case K_RAW:
523	kbd->kbdmode = VC_RAW;	523	kbd->kbdmode = VC_RAW;
524	break;	524	break;
525	case K_MEDIUMRAW:	525	case K_MEDIUMRAW:
526	kbd->kbdmode = VC_MEDIUMRAW;	526	kbd->kbdmode = VC_MEDIUMRAW;
527	break;	527	break;
528	case K_XLATE:	528	case K_XLATE:
529	kbd->kbdmode = VC_XLATE;	529	kbd->kbdmode = VC_XLATE;
530	compute_shiftstate();	530	compute_shiftstate();
531	break;	531	break;
532	case K_UNICODE:	532	case K_UNICODE:
533	kbd->kbdmode = VC_UNICODE;	533	kbd->kbdmode = VC_UNICODE;
534	compute_shiftstate();	534	compute_shiftstate();
535	break;	535	break;
536	default:	536	default:
537	return -EINVAL;	537	return -EINVAL;
538	}	538	}
539	tty_ldisc_flush(tty);	539	tty_ldisc_flush(tty);
540	return 0;	540	return 0;
541		541
542	case KDGKBMODE:	542	case KDGKBMODE:
543	ucval = ((kbd->kbdmode == VC_RAW) ? K_RAW :	543	ucval = ((kbd->kbdmode == VC_RAW) ? K_RAW :
544	(kbd->kbdmode == VC_MEDIUMRAW) ? K_MEDIUMRAW :	544	(kbd->kbdmode == VC_MEDIUMRAW) ? K_MEDIUMRAW :
545	(kbd->kbdmode == VC_UNICODE) ? K_UNICODE :	545	(kbd->kbdmode == VC_UNICODE) ? K_UNICODE :
546	K_XLATE);	546	K_XLATE);
547	goto setint;	547	goto setint;
548		548
549	/* this could be folded into KDSKBMODE, but for compatibility	549	/* this could be folded into KDSKBMODE, but for compatibility
550	reasons it is not so easy to fold KDGKBMETA into KDGKBMODE */	550	reasons it is not so easy to fold KDGKBMETA into KDGKBMODE */
551	case KDSKBMETA:	551	case KDSKBMETA:
552	switch(arg) {	552	switch(arg) {
553	case K_METABIT:	553	case K_METABIT:
554	clr_vc_kbd_mode(kbd, VC_META);	554	clr_vc_kbd_mode(kbd, VC_META);
555	break;	555	break;
556	case K_ESCPREFIX:	556	case K_ESCPREFIX:
557	set_vc_kbd_mode(kbd, VC_META);	557	set_vc_kbd_mode(kbd, VC_META);
558	break;	558	break;
559	default:	559	default:
560	return -EINVAL;	560	return -EINVAL;
561	}	561	}
562	return 0;	562	return 0;
563		563
564	case KDGKBMETA:	564	case KDGKBMETA:
565	ucval = (vc_kbd_mode(kbd, VC_META) ? K_ESCPREFIX : K_METABIT);	565	ucval = (vc_kbd_mode(kbd, VC_META) ? K_ESCPREFIX : K_METABIT);
566	setint:	566	setint:
567	return put_user(ucval, (int __user *)arg);	567	return put_user(ucval, (int __user *)arg);
568		568
569	case KDGETKEYCODE:	569	case KDGETKEYCODE:
570	case KDSETKEYCODE:	570	case KDSETKEYCODE:
571	if(!capable(CAP_SYS_TTY_CONFIG))	571	if(!capable(CAP_SYS_TTY_CONFIG))
572	perm=0;	572	perm=0;
573	return do_kbkeycode_ioctl(cmd, up, perm);	573	return do_kbkeycode_ioctl(cmd, up, perm);
574		574
575	case KDGKBENT:	575	case KDGKBENT:
576	case KDSKBENT:	576	case KDSKBENT:
577	return do_kdsk_ioctl(cmd, up, perm, kbd);	577	return do_kdsk_ioctl(cmd, up, perm, kbd);
578		578
579	case KDGKBSENT:	579	case KDGKBSENT:
580	case KDSKBSENT:	580	case KDSKBSENT:
581	return do_kdgkb_ioctl(cmd, up, perm);	581	return do_kdgkb_ioctl(cmd, up, perm);
582		582
583	case KDGKBDIACR:	583	case KDGKBDIACR:
584	{	584	{
585	struct kbdiacrs __user *a = up;	585	struct kbdiacrs __user *a = up;
586	struct kbdiacr diacr;	586	struct kbdiacr diacr;
587	int i;	587	int i;
588		588
589	if (put_user(accent_table_size, &a->kb_cnt))	589	if (put_user(accent_table_size, &a->kb_cnt))
590	return -EFAULT;	590	return -EFAULT;
591	for (i = 0; i < accent_table_size; i++) {	591	for (i = 0; i < accent_table_size; i++) {
592	diacr.diacr = conv_uni_to_8bit(accent_table[i].diacr);	592	diacr.diacr = conv_uni_to_8bit(accent_table[i].diacr);
593	diacr.base = conv_uni_to_8bit(accent_table[i].base);	593	diacr.base = conv_uni_to_8bit(accent_table[i].base);
594	diacr.result = conv_uni_to_8bit(accent_table[i].result);	594	diacr.result = conv_uni_to_8bit(accent_table[i].result);
595	if (copy_to_user(a->kbdiacr + i, &diacr, sizeof(struct kbdiacr)))	595	if (copy_to_user(a->kbdiacr + i, &diacr, sizeof(struct kbdiacr)))
596	return -EFAULT;	596	return -EFAULT;
597	}	597	}
598	return 0;	598	return 0;
599	}	599	}
600	case KDGKBDIACRUC:	600	case KDGKBDIACRUC:
601	{	601	{
602	struct kbdiacrsuc __user *a = up;	602	struct kbdiacrsuc __user *a = up;
603		603
604	if (put_user(accent_table_size, &a->kb_cnt))	604	if (put_user(accent_table_size, &a->kb_cnt))
605	return -EFAULT;	605	return -EFAULT;
606	if (copy_to_user(a->kbdiacruc, accent_table, accent_table_size*sizeof(struct kbdiacruc)))	606	if (copy_to_user(a->kbdiacruc, accent_table, accent_table_size*sizeof(struct kbdiacruc)))
607	return -EFAULT;	607	return -EFAULT;
608	return 0;	608	return 0;
609	}	609	}
610		610
611	case KDSKBDIACR:	611	case KDSKBDIACR:
612	{	612	{
613	struct kbdiacrs __user *a = up;	613	struct kbdiacrs __user *a = up;
614	struct kbdiacr diacr;	614	struct kbdiacr diacr;
615	unsigned int ct;	615	unsigned int ct;
616	int i;	616	int i;
617		617
618	if (!perm)	618	if (!perm)
619	return -EPERM;	619	return -EPERM;
620	if (get_user(ct,&a->kb_cnt))	620	if (get_user(ct,&a->kb_cnt))
621	return -EFAULT;	621	return -EFAULT;
622	if (ct >= MAX_DIACR)	622	if (ct >= MAX_DIACR)
623	return -EINVAL;	623	return -EINVAL;
624	accent_table_size = ct;	624	accent_table_size = ct;
625	for (i = 0; i < ct; i++) {	625	for (i = 0; i < ct; i++) {
626	if (copy_from_user(&diacr, a->kbdiacr + i, sizeof(struct kbdiacr)))	626	if (copy_from_user(&diacr, a->kbdiacr + i, sizeof(struct kbdiacr)))
627	return -EFAULT;	627	return -EFAULT;
628	accent_table[i].diacr = conv_8bit_to_uni(diacr.diacr);	628	accent_table[i].diacr = conv_8bit_to_uni(diacr.diacr);
629	accent_table[i].base = conv_8bit_to_uni(diacr.base);	629	accent_table[i].base = conv_8bit_to_uni(diacr.base);
630	accent_table[i].result = conv_8bit_to_uni(diacr.result);	630	accent_table[i].result = conv_8bit_to_uni(diacr.result);
631	}	631	}
632	return 0;	632	return 0;
633	}	633	}
634		634
635	case KDSKBDIACRUC:	635	case KDSKBDIACRUC:
636	{	636	{
637	struct kbdiacrsuc __user *a = up;	637	struct kbdiacrsuc __user *a = up;
638	unsigned int ct;	638	unsigned int ct;
639		639
640	if (!perm)	640	if (!perm)
641	return -EPERM;	641	return -EPERM;
642	if (get_user(ct,&a->kb_cnt))	642	if (get_user(ct,&a->kb_cnt))
643	return -EFAULT;	643	return -EFAULT;
644	if (ct >= MAX_DIACR)	644	if (ct >= MAX_DIACR)
645	return -EINVAL;	645	return -EINVAL;
646	accent_table_size = ct;	646	accent_table_size = ct;
647	if (copy_from_user(accent_table, a->kbdiacruc, ct*sizeof(struct kbdiacruc)))	647	if (copy_from_user(accent_table, a->kbdiacruc, ct*sizeof(struct kbdiacruc)))
648	return -EFAULT;	648	return -EFAULT;
649	return 0;	649	return 0;
650	}	650	}
651		651
652	/* the ioctls below read/set the flags usually shown in the leds */	652	/* the ioctls below read/set the flags usually shown in the leds */
653	/* don't use them - they will go away without warning */	653	/* don't use them - they will go away without warning */
654	case KDGKBLED:	654	case KDGKBLED:
655	ucval = kbd->ledflagstate \| (kbd->default_ledflagstate << 4);	655	ucval = kbd->ledflagstate \| (kbd->default_ledflagstate << 4);
656	goto setchar;	656	goto setchar;
657		657
658	case KDSKBLED:	658	case KDSKBLED:
659	if (!perm)	659	if (!perm)
660	return -EPERM;	660	return -EPERM;
661	if (arg & ~0x77)	661	if (arg & ~0x77)
662	return -EINVAL;	662	return -EINVAL;
663	kbd->ledflagstate = (arg & 7);	663	kbd->ledflagstate = (arg & 7);
664	kbd->default_ledflagstate = ((arg >> 4) & 7);	664	kbd->default_ledflagstate = ((arg >> 4) & 7);
665	set_leds();	665	set_leds();
666	return 0;	666	return 0;
667		667
668	/* the ioctls below only set the lights, not the functions */	668	/* the ioctls below only set the lights, not the functions */
669	/* for those, see KDGKBLED and KDSKBLED above */	669	/* for those, see KDGKBLED and KDSKBLED above */
670	case KDGETLED:	670	case KDGETLED:
671	ucval = getledstate();	671	ucval = getledstate();
672	setchar:	672	setchar:
673	return put_user(ucval, (char __user *)arg);	673	return put_user(ucval, (char __user *)arg);
674		674
675	case KDSETLED:	675	case KDSETLED:
676	if (!perm)	676	if (!perm)
677	return -EPERM;	677	return -EPERM;
678	setledstate(kbd, arg);	678	setledstate(kbd, arg);
679	return 0;	679	return 0;
680		680
681	/*	681	/*
682	* A process can indicate its willingness to accept signals	682	* A process can indicate its willingness to accept signals
683	* generated by pressing an appropriate key combination.	683	* generated by pressing an appropriate key combination.
684	* Thus, one can have a daemon that e.g. spawns a new console	684	* Thus, one can have a daemon that e.g. spawns a new console
685	* upon a keypress and then changes to it.	685	* upon a keypress and then changes to it.
686	* See also the kbrequest field of inittab(5).	686	* See also the kbrequest field of inittab(5).
687	*/	687	*/
688	case KDSIGACCEPT:	688	case KDSIGACCEPT:
689	{	689	{
690	if (!perm \|\| !capable(CAP_KILL))	690	if (!perm \|\| !capable(CAP_KILL))
691	return -EPERM;	691	return -EPERM;
692	if (!valid_signal(arg) \|\| arg < 1 \|\| arg == SIGKILL)	692	if (!valid_signal(arg) \|\| arg < 1 \|\| arg == SIGKILL)
693	return -EINVAL;	693	return -EINVAL;
694		694
695	spin_lock_irq(&vt_spawn_con.lock);	695	spin_lock_irq(&vt_spawn_con.lock);
696	put_pid(vt_spawn_con.pid);	696	put_pid(vt_spawn_con.pid);
697	vt_spawn_con.pid = get_pid(task_pid(current));	697	vt_spawn_con.pid = get_pid(task_pid(current));
698	vt_spawn_con.sig = arg;	698	vt_spawn_con.sig = arg;
699	spin_unlock_irq(&vt_spawn_con.lock);	699	spin_unlock_irq(&vt_spawn_con.lock);
700	return 0;	700	return 0;
701	}	701	}
702		702
703	case VT_SETMODE:	703	case VT_SETMODE:
704	{	704	{
705	struct vt_mode tmp;	705	struct vt_mode tmp;
706		706
707	if (!perm)	707	if (!perm)
708	return -EPERM;	708	return -EPERM;
709	if (copy_from_user(&tmp, up, sizeof(struct vt_mode)))	709	if (copy_from_user(&tmp, up, sizeof(struct vt_mode)))
710	return -EFAULT;	710	return -EFAULT;
711	if (tmp.mode != VT_AUTO && tmp.mode != VT_PROCESS)	711	if (tmp.mode != VT_AUTO && tmp.mode != VT_PROCESS)
712	return -EINVAL;	712	return -EINVAL;
713	acquire_console_sem();	713	acquire_console_sem();
714	vc->vt_mode = tmp;	714	vc->vt_mode = tmp;
715	/* the frsig is ignored, so we set it to 0 */	715	/* the frsig is ignored, so we set it to 0 */
716	vc->vt_mode.frsig = 0;	716	vc->vt_mode.frsig = 0;
717	put_pid(vc->vt_pid);	717	put_pid(vc->vt_pid);
718	vc->vt_pid = get_pid(task_pid(current));	718	vc->vt_pid = get_pid(task_pid(current));
719	/* no switch is required -- saw@shade.msu.ru */	719	/* no switch is required -- saw@shade.msu.ru */
720	vc->vt_newvt = -1;	720	vc->vt_newvt = -1;
721	release_console_sem();	721	release_console_sem();
722	return 0;	722	return 0;
723	}	723	}
724		724
725	case VT_GETMODE:	725	case VT_GETMODE:
726	{	726	{
727	struct vt_mode tmp;	727	struct vt_mode tmp;
728	int rc;	728	int rc;
729		729
730	acquire_console_sem();	730	acquire_console_sem();
731	memcpy(&tmp, &vc->vt_mode, sizeof(struct vt_mode));	731	memcpy(&tmp, &vc->vt_mode, sizeof(struct vt_mode));
732	release_console_sem();	732	release_console_sem();
733		733
734	rc = copy_to_user(up, &tmp, sizeof(struct vt_mode));	734	rc = copy_to_user(up, &tmp, sizeof(struct vt_mode));
735	return rc ? -EFAULT : 0;	735	return rc ? -EFAULT : 0;
736	}	736	}
737		737
738	/*	738	/*
739	* Returns global vt state. Note that VT 0 is always open, since	739	* Returns global vt state. Note that VT 0 is always open, since
740	* it's an alias for the current VT, and people can't use it here.	740	* it's an alias for the current VT, and people can't use it here.
741	* We cannot return state for more than 16 VTs, since v_state is short.	741	* We cannot return state for more than 16 VTs, since v_state is short.
742	*/	742	*/
743	case VT_GETSTATE:	743	case VT_GETSTATE:
744	{	744	{
745	struct vt_stat __user *vtstat = up;	745	struct vt_stat __user *vtstat = up;
746	unsigned short state, mask;	746	unsigned short state, mask;
747		747
748	if (put_user(fg_console + 1, &vtstat->v_active))	748	if (put_user(fg_console + 1, &vtstat->v_active))
749	return -EFAULT;	749	return -EFAULT;
750	state = 1; /* /dev/tty0 is always open */	750	state = 1; /* /dev/tty0 is always open */
751	for (i = 0, mask = 2; i < MAX_NR_CONSOLES && mask; ++i, mask <<= 1)	751	for (i = 0, mask = 2; i < MAX_NR_CONSOLES && mask; ++i, mask <<= 1)
752	if (VT_IS_IN_USE(i))	752	if (VT_IS_IN_USE(i))
753	state \|= mask;	753	state \|= mask;
754	return put_user(state, &vtstat->v_state);	754	return put_user(state, &vtstat->v_state);
755	}	755	}
756		756
757	/*	757	/*
758	* Returns the first available (non-opened) console.	758	* Returns the first available (non-opened) console.
759	*/	759	*/
760	case VT_OPENQRY:	760	case VT_OPENQRY:
761	for (i = 0; i < MAX_NR_CONSOLES; ++i)	761	for (i = 0; i < MAX_NR_CONSOLES; ++i)
762	if (! VT_IS_IN_USE(i))	762	if (! VT_IS_IN_USE(i))
763	break;	763	break;
764	ucval = i < MAX_NR_CONSOLES ? (i+1) : -1;	764	ucval = i < MAX_NR_CONSOLES ? (i+1) : -1;
765	goto setint;	765	goto setint;
766		766
767	/*	767	/*
768	* ioctl(fd, VT_ACTIVATE, num) will cause us to switch to vt # num,	768	* ioctl(fd, VT_ACTIVATE, num) will cause us to switch to vt # num,
769	* with num >= 1 (switches to vt 0, our console, are not allowed, just	769	* with num >= 1 (switches to vt 0, our console, are not allowed, just
770	* to preserve sanity).	770	* to preserve sanity).
771	*/	771	*/
772	case VT_ACTIVATE:	772	case VT_ACTIVATE:
773	if (!perm)	773	if (!perm)
774	return -EPERM;	774	return -EPERM;
775	if (arg == 0 \|\| arg > MAX_NR_CONSOLES)	775	if (arg == 0 \|\| arg > MAX_NR_CONSOLES)
776	return -ENXIO;	776	return -ENXIO;
777	arg--;	777	arg--;
778	acquire_console_sem();	778	acquire_console_sem();
779	i = vc_allocate(arg);	779	i = vc_allocate(arg);
780	release_console_sem();	780	release_console_sem();
781	if (i)	781	if (i)
782	return i;	782	return i;
783	set_console(arg);	783	set_console(arg);
784	return 0;	784	return 0;
785		785
786	/*	786	/*
787	* wait until the specified VT has been activated	787	* wait until the specified VT has been activated
788	*/	788	*/
789	case VT_WAITACTIVE:	789	case VT_WAITACTIVE:
790	if (!perm)	790	if (!perm)
791	return -EPERM;	791	return -EPERM;
792	if (arg == 0 \|\| arg > MAX_NR_CONSOLES)	792	if (arg == 0 \|\| arg > MAX_NR_CONSOLES)
793	return -ENXIO;	793	return -ENXIO;
794	return vt_waitactive(arg-1);	794	return vt_waitactive(arg-1);
795		795
796	/*	796	/*
797	* If a vt is under process control, the kernel will not switch to it	797	* If a vt is under process control, the kernel will not switch to it
798	* immediately, but postpone the operation until the process calls this	798	* immediately, but postpone the operation until the process calls this
799	* ioctl, allowing the switch to complete.	799	* ioctl, allowing the switch to complete.
800	*	800	*
801	* According to the X sources this is the behavior:	801	* According to the X sources this is the behavior:
802	* 0: pending switch-from not OK	802	* 0: pending switch-from not OK
803	* 1: pending switch-from OK	803	* 1: pending switch-from OK
804	* 2: completed switch-to OK	804	* 2: completed switch-to OK
805	*/	805	*/
806	case VT_RELDISP:	806	case VT_RELDISP:
807	if (!perm)	807	if (!perm)
808	return -EPERM;	808	return -EPERM;
809	if (vc->vt_mode.mode != VT_PROCESS)	809	if (vc->vt_mode.mode != VT_PROCESS)
810	return -EINVAL;	810	return -EINVAL;
811		811
812	/*	812	/*
813	* Switching-from response	813	* Switching-from response
814	*/	814	*/
815	acquire_console_sem();	815	acquire_console_sem();
816	if (vc->vt_newvt >= 0) {	816	if (vc->vt_newvt >= 0) {
817	if (arg == 0)	817	if (arg == 0)
818	/*	818	/*
819	* Switch disallowed, so forget we were trying	819	* Switch disallowed, so forget we were trying
820	* to do it.	820	* to do it.
821	*/	821	*/
822	vc->vt_newvt = -1;	822	vc->vt_newvt = -1;
823		823
824	else {	824	else {
825	/*	825	/*
826	* The current vt has been released, so	826	* The current vt has been released, so
827	* complete the switch.	827	* complete the switch.
828	*/	828	*/
829	int newvt;	829	int newvt;
830	newvt = vc->vt_newvt;	830	newvt = vc->vt_newvt;
831	vc->vt_newvt = -1;	831	vc->vt_newvt = -1;
832	i = vc_allocate(newvt);	832	i = vc_allocate(newvt);
833	if (i) {	833	if (i) {
834	release_console_sem();	834	release_console_sem();
835	return i;	835	return i;
836	}	836	}
837	/*	837	/*
838	* When we actually do the console switch,	838	* When we actually do the console switch,
839	* make sure we are atomic with respect to	839	* make sure we are atomic with respect to
840	* other console switches..	840	* other console switches..
841	*/	841	*/
842	complete_change_console(vc_cons[newvt].d);	842	complete_change_console(vc_cons[newvt].d);
843	}	843	}
844	}	844	}
845		845
846	/*	846	/*
847	* Switched-to response	847	* Switched-to response
848	*/	848	*/
849	else	849	else
850	{	850	{
851	/*	851	/*
852	* If it's just an ACK, ignore it	852	* If it's just an ACK, ignore it
853	*/	853	*/
854	if (arg != VT_ACKACQ) {	854	if (arg != VT_ACKACQ) {
855	release_console_sem();	855	release_console_sem();
856	return -EINVAL;	856	return -EINVAL;
857	}	857	}
858	}	858	}
859	release_console_sem();	859	release_console_sem();
860		860
861	return 0;	861	return 0;
862		862
863	/*	863	/*
864	* Disallocate memory associated to VT (but leave VT1)	864	* Disallocate memory associated to VT (but leave VT1)
865	*/	865	*/
866	case VT_DISALLOCATE:	866	case VT_DISALLOCATE:
867	if (arg > MAX_NR_CONSOLES)	867	if (arg > MAX_NR_CONSOLES)
868	return -ENXIO;	868	return -ENXIO;
869	if (arg == 0) {	869	if (arg == 0) {
870	/* deallocate all unused consoles, but leave 0 */	870	/* deallocate all unused consoles, but leave 0 */
871	acquire_console_sem();	871	acquire_console_sem();
872	for (i=1; i<MAX_NR_CONSOLES; i++)	872	for (i=1; i<MAX_NR_CONSOLES; i++)
873	if (! VT_BUSY(i))	873	if (! VT_BUSY(i))
874	vc_deallocate(i);	874	vc_deallocate(i);
875	release_console_sem();	875	release_console_sem();
876	} else {	876	} else {
877	/* deallocate a single console, if possible */	877	/* deallocate a single console, if possible */
878	arg--;	878	arg--;
879	if (VT_BUSY(arg))	879	if (VT_BUSY(arg))
880	return -EBUSY;	880	return -EBUSY;
881	if (arg) { /* leave 0 */	881	if (arg) { /* leave 0 */
882	acquire_console_sem();	882	acquire_console_sem();
883	vc_deallocate(arg);	883	vc_deallocate(arg);
884	release_console_sem();	884	release_console_sem();
885	}	885	}
886	}	886	}
887	return 0;	887	return 0;
888		888
889	case VT_RESIZE:	889	case VT_RESIZE:
890	{	890	{
891	struct vt_sizes __user *vtsizes = up;	891	struct vt_sizes __user *vtsizes = up;
892	struct vc_data *vc;	892	struct vc_data *vc;
893		893
894	ushort ll,cc;	894	ushort ll,cc;
895	if (!perm)	895	if (!perm)
896	return -EPERM;	896	return -EPERM;
897	if (get_user(ll, &vtsizes->v_rows) \|\|	897	if (get_user(ll, &vtsizes->v_rows) \|\|
898	get_user(cc, &vtsizes->v_cols))	898	get_user(cc, &vtsizes->v_cols))
899	return -EFAULT;	899	return -EFAULT;
900		900
901	for (i = 0; i < MAX_NR_CONSOLES; i++) {	901	for (i = 0; i < MAX_NR_CONSOLES; i++) {
902	vc = vc_cons[i].d;	902	vc = vc_cons[i].d;
903		903
904	if (vc) {	904	if (vc) {
905	vc->vc_resize_user = 1;	905	vc->vc_resize_user = 1;
906	vc_lock_resize(vc_cons[i].d, cc, ll);	906	vc_lock_resize(vc_cons[i].d, cc, ll);
907	}	907	}
908	}	908	}
909		909
910	return 0;	910	return 0;
911	}	911	}
912		912
913	case VT_RESIZEX:	913	case VT_RESIZEX:
914	{	914	{
915	struct vt_consize __user *vtconsize = up;	915	struct vt_consize __user *vtconsize = up;
916	ushort ll,cc,vlin,clin,vcol,ccol;	916	ushort ll,cc,vlin,clin,vcol,ccol;
917	if (!perm)	917	if (!perm)
918	return -EPERM;	918	return -EPERM;
919	if (!access_ok(VERIFY_READ, vtconsize,	919	if (!access_ok(VERIFY_READ, vtconsize,
920	sizeof(struct vt_consize)))	920	sizeof(struct vt_consize)))
921	return -EFAULT;	921	return -EFAULT;
922	__get_user(ll, &vtconsize->v_rows);	922	__get_user(ll, &vtconsize->v_rows);
923	__get_user(cc, &vtconsize->v_cols);	923	__get_user(cc, &vtconsize->v_cols);
924	__get_user(vlin, &vtconsize->v_vlin);	924	__get_user(vlin, &vtconsize->v_vlin);
925	__get_user(clin, &vtconsize->v_clin);	925	__get_user(clin, &vtconsize->v_clin);
926	__get_user(vcol, &vtconsize->v_vcol);	926	__get_user(vcol, &vtconsize->v_vcol);
927	__get_user(ccol, &vtconsize->v_ccol);	927	__get_user(ccol, &vtconsize->v_ccol);
928	vlin = vlin ? vlin : vc->vc_scan_lines;	928	vlin = vlin ? vlin : vc->vc_scan_lines;
929	if (clin) {	929	if (clin) {
930	if (ll) {	930	if (ll) {
931	if (ll != vlin/clin)	931	if (ll != vlin/clin)
932	return -EINVAL; /* Parameters don't add up */	932	return -EINVAL; /* Parameters don't add up */
933	} else	933	} else
934	ll = vlin/clin;	934	ll = vlin/clin;
935	}	935	}
936	if (vcol && ccol) {	936	if (vcol && ccol) {
937	if (cc) {	937	if (cc) {
938	if (cc != vcol/ccol)	938	if (cc != vcol/ccol)
939	return -EINVAL;	939	return -EINVAL;
940	} else	940	} else
941	cc = vcol/ccol;	941	cc = vcol/ccol;
942	}	942	}
943		943
944	if (clin > 32)	944	if (clin > 32)
945	return -EINVAL;	945	return -EINVAL;
946		946
947	for (i = 0; i < MAX_NR_CONSOLES; i++) {	947	for (i = 0; i < MAX_NR_CONSOLES; i++) {
948	if (!vc_cons[i].d)	948	if (!vc_cons[i].d)
949	continue;	949	continue;
950	acquire_console_sem();	950	acquire_console_sem();
951	if (vlin)	951	if (vlin)
952	vc_cons[i].d->vc_scan_lines = vlin;	952	vc_cons[i].d->vc_scan_lines = vlin;
953	if (clin)	953	if (clin)
954	vc_cons[i].d->vc_font.height = clin;	954	vc_cons[i].d->vc_font.height = clin;
955	vc_cons[i].d->vc_resize_user = 1;	955	vc_cons[i].d->vc_resize_user = 1;
956	vc_resize(vc_cons[i].d, cc, ll);	956	vc_resize(vc_cons[i].d, cc, ll);
957	release_console_sem();	957	release_console_sem();
958	}	958	}
959	return 0;	959	return 0;
960	}	960	}
961		961
962	case PIO_FONT: {	962	case PIO_FONT: {
963	if (!perm)	963	if (!perm)
964	return -EPERM;	964	return -EPERM;
965	op.op = KD_FONT_OP_SET;	965	op.op = KD_FONT_OP_SET;
966	op.flags = KD_FONT_FLAG_OLD \| KD_FONT_FLAG_DONT_RECALC; /* Compatibility */	966	op.flags = KD_FONT_FLAG_OLD \| KD_FONT_FLAG_DONT_RECALC; /* Compatibility */
967	op.width = 8;	967	op.width = 8;
968	op.height = 0;	968	op.height = 0;
969	op.charcount = 256;	969	op.charcount = 256;
970	op.data = up;	970	op.data = up;
971	return con_font_op(vc_cons[fg_console].d, &op);	971	return con_font_op(vc_cons[fg_console].d, &op);
972	}	972	}
973		973
974	case GIO_FONT: {	974	case GIO_FONT: {
975	op.op = KD_FONT_OP_GET;	975	op.op = KD_FONT_OP_GET;
976	op.flags = KD_FONT_FLAG_OLD;	976	op.flags = KD_FONT_FLAG_OLD;
977	op.width = 8;	977	op.width = 8;
978	op.height = 32;	978	op.height = 32;
979	op.charcount = 256;	979	op.charcount = 256;
980	op.data = up;	980	op.data = up;
981	return con_font_op(vc_cons[fg_console].d, &op);	981	return con_font_op(vc_cons[fg_console].d, &op);
982	}	982	}
983		983
984	case PIO_CMAP:	984	case PIO_CMAP:
985	if (!perm)	985	if (!perm)
986	return -EPERM;	986	return -EPERM;
987	return con_set_cmap(up);	987	return con_set_cmap(up);
988		988
989	case GIO_CMAP:	989	case GIO_CMAP:
990	return con_get_cmap(up);	990	return con_get_cmap(up);
991		991
992	case PIO_FONTX:	992	case PIO_FONTX:
993	case GIO_FONTX:	993	case GIO_FONTX:
994	return do_fontx_ioctl(cmd, up, perm, &op);	994	return do_fontx_ioctl(cmd, up, perm, &op);
995		995
996	case PIO_FONTRESET:	996	case PIO_FONTRESET:
997	{	997	{
998	if (!perm)	998	if (!perm)
999	return -EPERM;	999	return -EPERM;
1000		1000
1001	#ifdef BROKEN_GRAPHICS_PROGRAMS	1001	#ifdef BROKEN_GRAPHICS_PROGRAMS
1002	/* With BROKEN_GRAPHICS_PROGRAMS defined, the default	1002	/* With BROKEN_GRAPHICS_PROGRAMS defined, the default
1003	font is not saved. */	1003	font is not saved. */
1004	return -ENOSYS;	1004	return -ENOSYS;
1005	#else	1005	#else
1006	{	1006	{
1007	op.op = KD_FONT_OP_SET_DEFAULT;	1007	op.op = KD_FONT_OP_SET_DEFAULT;
1008	op.data = NULL;	1008	op.data = NULL;
1009	i = con_font_op(vc_cons[fg_console].d, &op);	1009	i = con_font_op(vc_cons[fg_console].d, &op);
1010	if (i)	1010	if (i)
1011	return i;	1011	return i;
1012	con_set_default_unimap(vc_cons[fg_console].d);	1012	con_set_default_unimap(vc_cons[fg_console].d);
1013	return 0;	1013	return 0;
1014	}	1014	}
1015	#endif	1015	#endif
1016	}	1016	}
1017		1017
1018	case KDFONTOP: {	1018	case KDFONTOP: {
1019	if (copy_from_user(&op, up, sizeof(op)))	1019	if (copy_from_user(&op, up, sizeof(op)))
1020	return -EFAULT;	1020	return -EFAULT;
1021	if (!perm && op.op != KD_FONT_OP_GET)	1021	if (!perm && op.op != KD_FONT_OP_GET)
1022	return -EPERM;	1022	return -EPERM;
1023	i = con_font_op(vc, &op);	1023	i = con_font_op(vc, &op);
1024	if (i) return i;	1024	if (i) return i;
1025	if (copy_to_user(up, &op, sizeof(op)))	1025	if (copy_to_user(up, &op, sizeof(op)))
1026	return -EFAULT;	1026	return -EFAULT;
1027	return 0;	1027	return 0;
1028	}	1028	}
1029		1029
1030	case PIO_SCRNMAP:	1030	case PIO_SCRNMAP:
1031	if (!perm)	1031	if (!perm)
1032	return -EPERM;	1032	return -EPERM;
1033	return con_set_trans_old(up);	1033	return con_set_trans_old(up);
1034		1034
1035	case GIO_SCRNMAP:	1035	case GIO_SCRNMAP:
1036	return con_get_trans_old(up);	1036	return con_get_trans_old(up);
1037		1037
1038	case PIO_UNISCRNMAP:	1038	case PIO_UNISCRNMAP:
1039	if (!perm)	1039	if (!perm)
1040	return -EPERM;	1040	return -EPERM;
1041	return con_set_trans_new(up);	1041	return con_set_trans_new(up);
1042		1042
1043	case GIO_UNISCRNMAP:	1043	case GIO_UNISCRNMAP:
1044	return con_get_trans_new(up);	1044	return con_get_trans_new(up);
1045		1045
1046	case PIO_UNIMAPCLR:	1046	case PIO_UNIMAPCLR:
1047	{ struct unimapinit ui;	1047	{ struct unimapinit ui;
1048	if (!perm)	1048	if (!perm)
1049	return -EPERM;	1049	return -EPERM;
1050	i = copy_from_user(&ui, up, sizeof(struct unimapinit));	1050	i = copy_from_user(&ui, up, sizeof(struct unimapinit));
1051	if (i) return -EFAULT;	1051	if (i) return -EFAULT;
1052	con_clear_unimap(vc, &ui);	1052	con_clear_unimap(vc, &ui);
1053	return 0;	1053	return 0;
1054	}	1054	}
1055		1055
1056	case PIO_UNIMAP:	1056	case PIO_UNIMAP:
1057	case GIO_UNIMAP:	1057	case GIO_UNIMAP:
1058	return do_unimap_ioctl(cmd, up, perm, vc);	1058	return do_unimap_ioctl(cmd, up, perm, vc);
1059		1059
1060	case VT_LOCKSWITCH:	1060	case VT_LOCKSWITCH:
1061	if (!capable(CAP_SYS_TTY_CONFIG))	1061	if (!capable(CAP_SYS_TTY_CONFIG))
1062	return -EPERM;	1062	return -EPERM;
1063	vt_dont_switch = 1;	1063	vt_dont_switch = 1;
1064	return 0;	1064	return 0;
1065	case VT_UNLOCKSWITCH:	1065	case VT_UNLOCKSWITCH:
1066	if (!capable(CAP_SYS_TTY_CONFIG))	1066	if (!capable(CAP_SYS_TTY_CONFIG))
1067	return -EPERM;	1067	return -EPERM;
1068	vt_dont_switch = 0;	1068	vt_dont_switch = 0;
1069	return 0;	1069	return 0;
1070	case VT_GETHIFONTMASK:	1070	case VT_GETHIFONTMASK:
1071	return put_user(vc->vc_hi_font_mask, (unsigned short __user *)arg);	1071	return put_user(vc->vc_hi_font_mask, (unsigned short __user *)arg);
1072	default:	1072	default:
1073	return -ENOIOCTLCMD;	1073	return -ENOIOCTLCMD;
1074	}	1074	}
1075	}	1075	}
1076		1076
1077	/*	1077	/*
1078	* Sometimes we want to wait until a particular VT has been activated. We	1078	* Sometimes we want to wait until a particular VT has been activated. We
1079	* do it in a very simple manner. Everybody waits on a single queue and	1079	* do it in a very simple manner. Everybody waits on a single queue and
1080	* get woken up at once. Those that are satisfied go on with their business,	1080	* get woken up at once. Those that are satisfied go on with their business,
1081	* while those not ready go back to sleep. Seems overkill to add a wait	1081	* while those not ready go back to sleep. Seems overkill to add a wait
1082	* to each vt just for this - usually this does nothing!	1082	* to each vt just for this - usually this does nothing!
1083	*/	1083	*/
1084	static DECLARE_WAIT_QUEUE_HEAD(vt_activate_queue);	1084	static DECLARE_WAIT_QUEUE_HEAD(vt_activate_queue);
1085		1085
1086	/*	1086	/*
1087	* Sleeps until a vt is activated, or the task is interrupted. Returns	1087	* Sleeps until a vt is activated, or the task is interrupted. Returns
1088	* 0 if activation, -EINTR if interrupted by a signal handler.	1088	* 0 if activation, -EINTR if interrupted by a signal handler.
1089	*/	1089	*/
1090	int vt_waitactive(int vt)	1090	int vt_waitactive(int vt)
1091	{	1091	{
1092	int retval;	1092	int retval;
1093	DECLARE_WAITQUEUE(wait, current);	1093	DECLARE_WAITQUEUE(wait, current);
1094		1094
1095	add_wait_queue(&vt_activate_queue, &wait);	1095	add_wait_queue(&vt_activate_queue, &wait);
1096	for (;;) {	1096	for (;;) {
1097	retval = 0;	1097	retval = 0;
1098		1098
1099	/*	1099	/*
1100	* Synchronize with redraw_screen(). By acquiring the console	1100	* Synchronize with redraw_screen(). By acquiring the console
1101	* semaphore we make sure that the console switch is completed	1101	* semaphore we make sure that the console switch is completed
1102	* before we return. If we didn't wait for the semaphore, we	1102	* before we return. If we didn't wait for the semaphore, we
1103	* could return at a point where fg_console has already been	1103	* could return at a point where fg_console has already been
1104	* updated, but the console switch hasn't been completed.	1104	* updated, but the console switch hasn't been completed.
1105	*/	1105	*/
1106	acquire_console_sem();	1106	acquire_console_sem();
1107	set_current_state(TASK_INTERRUPTIBLE);	1107	set_current_state(TASK_INTERRUPTIBLE);
1108	if (vt == fg_console) {	1108	if (vt == fg_console) {
1109	release_console_sem();	1109	release_console_sem();
1110	break;	1110	break;
1111	}	1111	}
1112	release_console_sem();	1112	release_console_sem();
1113	retval = -ERESTARTNOHAND;	1113	retval = -ERESTARTNOHAND;
1114	if (signal_pending(current))	1114	if (signal_pending(current))
1115	break;	1115	break;
1116	schedule();	1116	schedule();
1117	}	1117	}
1118	remove_wait_queue(&vt_activate_queue, &wait);	1118	remove_wait_queue(&vt_activate_queue, &wait);
1119	__set_current_state(TASK_RUNNING);	1119	__set_current_state(TASK_RUNNING);
1120	return retval;	1120	return retval;
1121	}	1121	}
1122		1122
1123	#define vt_wake_waitactive() wake_up(&vt_activate_queue)	1123	#define vt_wake_waitactive() wake_up(&vt_activate_queue)
1124		1124
1125	void reset_vc(struct vc_data *vc)	1125	void reset_vc(struct vc_data *vc)
1126	{	1126	{
1127	vc->vc_mode = KD_TEXT;	1127	vc->vc_mode = KD_TEXT;
1128	kbd_table[vc->vc_num].kbdmode = VC_XLATE;	1128	kbd_table[vc->vc_num].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
1129	vc->vt_mode.mode = VT_AUTO;	1129	vc->vt_mode.mode = VT_AUTO;
1130	vc->vt_mode.waitv = 0;	1130	vc->vt_mode.waitv = 0;
1131	vc->vt_mode.relsig = 0;	1131	vc->vt_mode.relsig = 0;
1132	vc->vt_mode.acqsig = 0;	1132	vc->vt_mode.acqsig = 0;
1133	vc->vt_mode.frsig = 0;	1133	vc->vt_mode.frsig = 0;
1134	put_pid(vc->vt_pid);	1134	put_pid(vc->vt_pid);
1135	vc->vt_pid = NULL;	1135	vc->vt_pid = NULL;
1136	vc->vt_newvt = -1;	1136	vc->vt_newvt = -1;
1137	if (!in_interrupt()) /* Via keyboard.c:SAK() - akpm */	1137	if (!in_interrupt()) /* Via keyboard.c:SAK() - akpm */
1138	reset_palette(vc);	1138	reset_palette(vc);
1139	}	1139	}
1140		1140
1141	void vc_SAK(struct work_struct *work)	1141	void vc_SAK(struct work_struct *work)
1142	{	1142	{
1143	struct vc *vc_con =	1143	struct vc *vc_con =
1144	container_of(work, struct vc, SAK_work);	1144	container_of(work, struct vc, SAK_work);
1145	struct vc_data *vc;	1145	struct vc_data *vc;
1146	struct tty_struct *tty;	1146	struct tty_struct *tty;
1147		1147
1148	acquire_console_sem();	1148	acquire_console_sem();
1149	vc = vc_con->d;	1149	vc = vc_con->d;
1150	if (vc) {	1150	if (vc) {
1151	tty = vc->vc_tty;	1151	tty = vc->vc_tty;
1152	/*	1152	/*
1153	* SAK should also work in all raw modes and reset	1153	* SAK should also work in all raw modes and reset
1154	* them properly.	1154	* them properly.
1155	*/	1155	*/
1156	if (tty)	1156	if (tty)
1157	__do_SAK(tty);	1157	__do_SAK(tty);
1158	reset_vc(vc);	1158	reset_vc(vc);
1159	}	1159	}
1160	release_console_sem();	1160	release_console_sem();
1161	}	1161	}
1162		1162
1163	/*	1163	/*
1164	* Performs the back end of a vt switch	1164	* Performs the back end of a vt switch
1165	*/	1165	*/
1166	static void complete_change_console(struct vc_data *vc)	1166	static void complete_change_console(struct vc_data *vc)
1167	{	1167	{
1168	unsigned char old_vc_mode;	1168	unsigned char old_vc_mode;
1169		1169
1170	last_console = fg_console;	1170	last_console = fg_console;
1171		1171
1172	/*	1172	/*
1173	* If we're switching, we could be going from KD_GRAPHICS to	1173	* If we're switching, we could be going from KD_GRAPHICS to
1174	* KD_TEXT mode or vice versa, which means we need to blank or	1174	* KD_TEXT mode or vice versa, which means we need to blank or
1175	* unblank the screen later.	1175	* unblank the screen later.
1176	*/	1176	*/
1177	old_vc_mode = vc_cons[fg_console].d->vc_mode;	1177	old_vc_mode = vc_cons[fg_console].d->vc_mode;
1178	switch_screen(vc);	1178	switch_screen(vc);
1179		1179
1180	/*	1180	/*
1181	* This can't appear below a successful kill_pid(). If it did,	1181	* This can't appear below a successful kill_pid(). If it did,
1182	* then the *blank_screen operation could occur while X, having	1182	* then the *blank_screen operation could occur while X, having
1183	* received acqsig, is waking up on another processor. This	1183	* received acqsig, is waking up on another processor. This
1184	* condition can lead to overlapping accesses to the VGA range	1184	* condition can lead to overlapping accesses to the VGA range
1185	* and the framebuffer (causing system lockups).	1185	* and the framebuffer (causing system lockups).
1186	*	1186	*
1187	* To account for this we duplicate this code below only if the	1187	* To account for this we duplicate this code below only if the
1188	* controlling process is gone and we've called reset_vc.	1188	* controlling process is gone and we've called reset_vc.
1189	*/	1189	*/
1190	if (old_vc_mode != vc->vc_mode) {	1190	if (old_vc_mode != vc->vc_mode) {
1191	if (vc->vc_mode == KD_TEXT)	1191	if (vc->vc_mode == KD_TEXT)
1192	do_unblank_screen(1);	1192	do_unblank_screen(1);
1193	else	1193	else
1194	do_blank_screen(1);	1194	do_blank_screen(1);
1195	}	1195	}
1196		1196
1197	/*	1197	/*
1198	* If this new console is under process control, send it a signal	1198	* If this new console is under process control, send it a signal
1199	* telling it that it has acquired. Also check if it has died and	1199	* telling it that it has acquired. Also check if it has died and
1200	* clean up (similar to logic employed in change_console())	1200	* clean up (similar to logic employed in change_console())
1201	*/	1201	*/
1202	if (vc->vt_mode.mode == VT_PROCESS) {	1202	if (vc->vt_mode.mode == VT_PROCESS) {
1203	/*	1203	/*
1204	* Send the signal as privileged - kill_pid() will	1204	* Send the signal as privileged - kill_pid() will
1205	* tell us if the process has gone or something else	1205	* tell us if the process has gone or something else
1206	* is awry	1206	* is awry
1207	*/	1207	*/
1208	if (kill_pid(vc->vt_pid, vc->vt_mode.acqsig, 1) != 0) {	1208	if (kill_pid(vc->vt_pid, vc->vt_mode.acqsig, 1) != 0) {
1209	/*	1209	/*
1210	* The controlling process has died, so we revert back to	1210	* The controlling process has died, so we revert back to
1211	* normal operation. In this case, we'll also change back	1211	* normal operation. In this case, we'll also change back
1212	* to KD_TEXT mode. I'm not sure if this is strictly correct	1212	* to KD_TEXT mode. I'm not sure if this is strictly correct
1213	* but it saves the agony when the X server dies and the screen	1213	* but it saves the agony when the X server dies and the screen
1214	* remains blanked due to KD_GRAPHICS! It would be nice to do	1214	* remains blanked due to KD_GRAPHICS! It would be nice to do
1215	* this outside of VT_PROCESS but there is no single process	1215	* this outside of VT_PROCESS but there is no single process
1216	* to account for and tracking tty count may be undesirable.	1216	* to account for and tracking tty count may be undesirable.
1217	*/	1217	*/
1218	reset_vc(vc);	1218	reset_vc(vc);
1219		1219
1220	if (old_vc_mode != vc->vc_mode) {	1220	if (old_vc_mode != vc->vc_mode) {
1221	if (vc->vc_mode == KD_TEXT)	1221	if (vc->vc_mode == KD_TEXT)
1222	do_unblank_screen(1);	1222	do_unblank_screen(1);
1223	else	1223	else
1224	do_blank_screen(1);	1224	do_blank_screen(1);
1225	}	1225	}
1226	}	1226	}
1227	}	1227	}
1228		1228
1229	/*	1229	/*
1230	* Wake anyone waiting for their VT to activate	1230	* Wake anyone waiting for their VT to activate
1231	*/	1231	*/
1232	vt_wake_waitactive();	1232	vt_wake_waitactive();
1233	return;	1233	return;
1234	}	1234	}
1235		1235
1236	/*	1236	/*
1237	* Performs the front-end of a vt switch	1237	* Performs the front-end of a vt switch
1238	*/	1238	*/
1239	void change_console(struct vc_data *new_vc)	1239	void change_console(struct vc_data *new_vc)
1240	{	1240	{
1241	struct vc_data *vc;	1241	struct vc_data *vc;
1242		1242
1243	if (!new_vc \|\| new_vc->vc_num == fg_console \|\| vt_dont_switch)	1243	if (!new_vc \|\| new_vc->vc_num == fg_console \|\| vt_dont_switch)
1244	return;	1244	return;
1245		1245
1246	/*	1246	/*
1247	* If this vt is in process mode, then we need to handshake with	1247	* If this vt is in process mode, then we need to handshake with
1248	* that process before switching. Essentially, we store where that	1248	* that process before switching. Essentially, we store where that
1249	* vt wants to switch to and wait for it to tell us when it's done	1249	* vt wants to switch to and wait for it to tell us when it's done
1250	* (via VT_RELDISP ioctl).	1250	* (via VT_RELDISP ioctl).
1251	*	1251	*
1252	* We also check to see if the controlling process still exists.	1252	* We also check to see if the controlling process still exists.
1253	* If it doesn't, we reset this vt to auto mode and continue.	1253	* If it doesn't, we reset this vt to auto mode and continue.
1254	* This is a cheap way to track process control. The worst thing	1254	* This is a cheap way to track process control. The worst thing
1255	* that can happen is: we send a signal to a process, it dies, and	1255	* that can happen is: we send a signal to a process, it dies, and
1256	* the switch gets "lost" waiting for a response; hopefully, the	1256	* the switch gets "lost" waiting for a response; hopefully, the
1257	* user will try again, we'll detect the process is gone (unless	1257	* user will try again, we'll detect the process is gone (unless
1258	* the user waits just the right amount of time :-) and revert the	1258	* the user waits just the right amount of time :-) and revert the
1259	* vt to auto control.	1259	* vt to auto control.
1260	*/	1260	*/
1261	vc = vc_cons[fg_console].d;	1261	vc = vc_cons[fg_console].d;
1262	if (vc->vt_mode.mode == VT_PROCESS) {	1262	if (vc->vt_mode.mode == VT_PROCESS) {
1263	/*	1263	/*
1264	* Send the signal as privileged - kill_pid() will	1264	* Send the signal as privileged - kill_pid() will
1265	* tell us if the process has gone or something else	1265	* tell us if the process has gone or something else
1266	* is awry.	1266	* is awry.
1267	*	1267	*
1268	* We need to set vt_newvt before sending the signal or we	1268	* We need to set vt_newvt before sending the signal or we
1269	* have a race.	1269	* have a race.
1270	*/	1270	*/
1271	vc->vt_newvt = new_vc->vc_num;	1271	vc->vt_newvt = new_vc->vc_num;
1272	if (kill_pid(vc->vt_pid, vc->vt_mode.relsig, 1) == 0) {	1272	if (kill_pid(vc->vt_pid, vc->vt_mode.relsig, 1) == 0) {
1273	/*	1273	/*
1274	* It worked. Mark the vt to switch to and	1274	* It worked. Mark the vt to switch to and
1275	* return. The process needs to send us a	1275	* return. The process needs to send us a
1276	* VT_RELDISP ioctl to complete the switch.	1276	* VT_RELDISP ioctl to complete the switch.
1277	*/	1277	*/
1278	return;	1278	return;
1279	}	1279	}
1280		1280
1281	/*	1281	/*
1282	* The controlling process has died, so we revert back to	1282	* The controlling process has died, so we revert back to
1283	* normal operation. In this case, we'll also change back	1283	* normal operation. In this case, we'll also change back
1284	* to KD_TEXT mode. I'm not sure if this is strictly correct	1284	* to KD_TEXT mode. I'm not sure if this is strictly correct
1285	* but it saves the agony when the X server dies and the screen	1285	* but it saves the agony when the X server dies and the screen
1286	* remains blanked due to KD_GRAPHICS! It would be nice to do	1286	* remains blanked due to KD_GRAPHICS! It would be nice to do
1287	* this outside of VT_PROCESS but there is no single process	1287	* this outside of VT_PROCESS but there is no single process
1288	* to account for and tracking tty count may be undesirable.	1288	* to account for and tracking tty count may be undesirable.
1289	*/	1289	*/
1290	reset_vc(vc);	1290	reset_vc(vc);
1291		1291
1292	/*	1292	/*
1293	* Fall through to normal (VT_AUTO) handling of the switch...	1293	* Fall through to normal (VT_AUTO) handling of the switch...
1294	*/	1294	*/
1295	}	1295	}
1296		1296
1297	/*	1297	/*
1298	* Ignore all switches in KD_GRAPHICS+VT_AUTO mode	1298	* Ignore all switches in KD_GRAPHICS+VT_AUTO mode
1299	*/	1299	*/
1300	if (vc->vc_mode == KD_GRAPHICS)	1300	if (vc->vc_mode == KD_GRAPHICS)
1301	return;	1301	return;
1302		1302
1303	complete_change_console(new_vc);	1303	complete_change_console(new_vc);
1304	}	1304	}
1305		1305

include/linux/vt_kern.h

Diff comments View file @ 2e8ecb9

 #ifndef _VT_KERN_H
 #define _VT_KERN_H
 /*
  * this really is an extension of the vc_cons structure in console.c, but
  * with information needed by the vt package
  */
 #include <linux/vt.h>
 #include <linux/kd.h>
 #include <linux/tty.h>
 #include <linux/mutex.h>
 #include <linux/console_struct.h>
 #include <linux/mm.h>
 /*
  * Presently, a lot of graphics programs do not restore the contents of
  * the higher font pages.  Defining this flag will avoid use of them, but
  * will lose support for PIO_FONTRESET.  Note that many font operations are
  * not likely to work with these programs anyway; they need to be
  * fixed.  The linux/Documentation directory includes a code snippet
  * to save and restore the text font.
  */
 #ifdef CONFIG_VGA_CONSOLE
 #define BROKEN_GRAPHICS_PROGRAMS 1
 #endif
 extern void kd_mksound(unsigned int hz, unsigned int ticks);
 extern int kbd_rate(struct kbd_repeat *rep);
 extern int fg_console, last_console, want_console;
 /* console.c */
 int vc_allocate(unsigned int console);
 int vc_cons_allocated(unsigned int console);
 int vc_resize(struct vc_data *vc, unsigned int cols, unsigned int lines);
 int vc_lock_resize(struct vc_data *vc, unsigned int cols, unsigned int lines);
 void vc_deallocate(unsigned int console);
 void reset_palette(struct vc_data *vc);
 void do_blank_screen(int entering_gfx);
 void do_unblank_screen(int leaving_gfx);
 void unblank_screen(void);
 void poke_blanked_console(void);
 int con_font_op(struct vc_data *vc, struct console_font_op *op);
 int con_set_cmap(unsigned char __user *cmap);
 int con_get_cmap(unsigned char __user *cmap);
 void scrollback(struct vc_data *vc, int lines);
 void scrollfront(struct vc_data *vc, int lines);
 void update_region(struct vc_data *vc, unsigned long start, int count);
 void redraw_screen(struct vc_data *vc, int is_switch);
 #define update_screen(x) redraw_screen(x, 0)
 #define switch_screen(x) redraw_screen(x, 1)
 struct tty_struct;
 int tioclinux(struct tty_struct *tty, unsigned long arg);
 /* consolemap.c */
 struct unimapinit;
 struct unipair;
 int con_set_trans_old(unsigned char __user * table);
 int con_get_trans_old(unsigned char __user * table);
 int con_set_trans_new(unsigned short __user * table);
 int con_get_trans_new(unsigned short __user * table);
 int con_clear_unimap(struct vc_data *vc, struct unimapinit *ui);
 int con_set_unimap(struct vc_data *vc, ushort ct, struct unipair __user *list);
 int con_get_unimap(struct vc_data *vc, ushort ct, ushort __user *uct, struct unipair __user *list);
 int con_set_default_unimap(struct vc_data *vc);
 void con_free_unimap(struct vc_data *vc);
 void con_protect_unimap(struct vc_data *vc, int rdonly);
 int con_copy_unimap(struct vc_data *dst_vc, struct vc_data *src_vc);
 /* vt.c */
 int vt_waitactive(int vt);
 void change_console(struct vc_data *new_vc);
 void reset_vc(struct vc_data *vc);
 extern int unbind_con_driver(const struct consw *csw, int first, int last,
 			     int deflt);
 /*
  * vc_screen.c shares this temporary buffer with the console write code so that
  * we can easily avoid touching user space while holding the console spinlock.
  */
 #define CON_BUF_SIZE (CONFIG_BASE_SMALL ? 256 : PAGE_SIZE)
 extern char con_buf[CON_BUF_SIZE];
 extern struct mutex con_buf_mtx;
 extern char vt_dont_switch;
+extern int default_utf8;
 struct vt_spawn_console {
 	spinlock_t lock;
 	struct pid *pid;
 	int sig;
 };
 extern struct vt_spawn_console vt_spawn_con;
 #endif /* _VT_KERN_H */