usr/src/uts/common/sys/kbd.h

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25
  26 #ifndef _SYS_KBD_H
  27 #define _SYS_KBD_H
  28
  29 #pragma ident   "%Z%%M% %I%     %E% SMI"        /* SunOS4.0 1.18 */
  30
  31 #ifdef  __cplusplus
  32 extern "C" {
  33 #endif
  34
  35 /*
  36  * Following #defines are related to the older keyboards which
  37  * are no longer supported by kb module.  The #defines ane left
  38  * for older programs to still compile.
  39  */
  40 #define KB_KLUNK        0x00            /* Micro Switch 103SD32-2 */
  41 #define KB_VT100        0x01            /* Keytronics VT100 compatible */
  42 #define KB_SUN2         0x02            /* Sun-2 custom keyboard */
  43 #define KB_VT220        0x81            /* Emulation VT220 */
  44 #define KB_VT220I       0x82            /* International VT220 Emulation */
  45
  46 #define NOTPRESENT      0xFF            /* Keyboard is not plugged in */
  47 #define KBD_CMD_LED1    0x04            /* Turn on LED 1 for Sun-2 */
  48 #define KBD_CMD_NOLED1  0x05            /* Turn off LED 1 for Sun-2 */
  49 #define KBD_CMD_LED2    0x06            /* Turn on LED 2 for Sun-2 */
  50 #define KBD_CMD_NOLED2  0x07            /* Turn off LED 2 for Sun-2 */
  51
  52 #define CTLSMASK        0x0100          /* Set if ^S was last keyed of ^S, ^Q */
  53                                         /* determines which NOSCROLL sends. */
  54
  55 #define NOSCROLL        0x303   /* This key alternately sends ^S or ^Q */
  56 #define CTRLS           0x304   /* This sends ^S and lets NOSCROLL know */
  57 #define CTRLQ           0x305   /* This sends ^Q and lets NOSCROLL know */
  58
  59
  60 /*
  61  * Following are the only keyboard types supported by kb module.
  62  * (Type 5, Hobo, US101A are also supported but they report
  63  * themselves as Type 4 keyboard with a different layout id.)
  64  */
  65 #define KB_SUN3         3               /* Type 3 Sun keyboard */
  66 #define KB_SUN4         4               /* Type 4 Sun keyboard */
  67 #define KB_USB          6               /* USB keyboard */
  68 #define KB_PC           101             /* Type 101 AT keyboard */
  69
  70 #define KB_ASCII        0x0F            /* Ascii terminal masquerading as kbd */
  71
  72 /*
  73  * This structure is used to enumerate the supported keyboard types.
  74  * The array of these is terminated by an entry with a NULL table entry.
  75  * The first entry is used if none match.
  76  */
  77 struct keyboards {
  78         int             id;     /* Keyboard type, per KIOCTYPE */
  79         struct keyboard *table; /* Keyboard table to use. */
  80 };
  81
  82 /*
  83  * Various special characters that might show up on the port
  84  */
  85 #define IDLEKEY         0x7F            /* Keyboard is idle; no keys down */
  86 #define ERRORKEY        0x7E            /* Keyboard detected an error */
  87 #define RESETKEY        0xFF            /* Keyboard was just reset */
  88 #define LAYOUTKEY       0xFE            /* Keyboard layout byte follows */
  89
  90 #define PRESSED         0x00            /* 0x80 bit off: key was pressed */
  91 #define RELEASED        0x80            /* 0x80 bit on : key was released */
  92
  93 /*
  94  * Commands to the Sun-3 keyboard.
  95  */
  96 #define KBD_CMD_RESET           0x01    /* Reset keyboard as if power-up */
  97 #define KBD_CMD_BELL            0x02    /* Turn on the bell */
  98 #define KBD_CMD_NOBELL          0x03    /* Turn off the bell */
  99 #define KBD_CMD_CLICK           0x0A    /* Turn on the click annunciator */
 100 #define KBD_CMD_NOCLICK         0x0B    /* Turn off the click annunciator */
 101
 102 /*
 103  * Commands to the Type 4 keyboard, in addition to those above.
 104  */
 105 #define KBD_CMD_AUTOTEST        0x0C    /* Initiate test sequence */
 106 #define KBD_CMD_SETLED          0x0E    /* Set keyboard LED's */
 107 #define KBD_CMD_GETLAYOUT       0x0F    /* Request that keyboard indicate */
 108                                         /* layout */
 109 /*
 110  * Type 4 keyboard LED masks (used to set LED's)
 111  */
 112 #define LED_NUM_LOCK    0x1
 113 #define LED_COMPOSE     0x2
 114 #define LED_SCROLL_LOCK 0x4
 115 #define LED_CAPS_LOCK   0x8
 116 #define LED_KANA        0x10            /* Valid only on Japanese layout */
 117
 118 /*
 119  * Software related definitions
 120  */
 121 /*
 122  * These are the states that the keyboard scanner can be in.
 123  *
 124  * It starts out in NORMAL state.
 125  */
 126 #define NORMAL          0               /* The usual (ho, hum) */
 127 #define ABORT1          1               /* Got KEYABORT1 */
 128 #define COMPOSE1        2               /* Got COMPOSE */
 129 #define COMPOSE2        3               /* Got COMPOSE plus first key */
 130 #define FLTACCENT       4               /* Got floating accent key */
 131 #define NEWABORT1       5               /* Got NEW KEYABORT1 */
 132
 133 /*
 134  * Size of ASCII set as used in compose handling.
 135  */
 136 #define ASCII_SET_SIZE  128
 137
 138 /*
 139  * These are how you can have your input translated.
 140  * TR_EVENT means that each keystroke is sent as a firm event.
 141  * TR_UNTRANS_EVENT also sends a firm event for each up / down transition,
 142  * but the value is untranslated: the event id is the key station; the
 143  * value indicates whether the transition was up or down; the value of the
 144  * shift-mask is undefined.
 145  */
 146 #define TR_NONE           0
 147 #define TR_ASCII          1
 148 #define TR_EVENT          2
 149 #define TR_UNTRANS_EVENT  3
 150
 151 /*
 152  * These bits can appear in the result of TR_NONE & TR_UNTRANS_EVENT getkey()s.
 153  */
 154 #define BUILDKEY(key, state)    (key | state)
 155 #define STATEOF(key)    ((key) & RELEASED)      /* 0 = key down, !=0 = key up */
 156 #define KEYOF(key)      ((key) & ~RELEASED)     /* The key number that moved */
 157 #define NOKEY           (-1)            /* The argument was 0, and no key was */
 158                                         /* depressed.  They were all elated. */
 159
 160 /*
 161  * "Bucky" bits.  These are bits for mode keys.  The META bit is ORed into the
 162  * result of TR_ASCII getkey()s, and can be ORed into the result of TR_EVENT
 163  * getkey()s for backwards compatibility.
 164  * (NOKEY can also appear if no keypress was queued up.)
 165  */
 166 #define METABIT         0               /* Meta key depressed with key */
 167 #define METAMASK        0x000080
 168 #define SYSTEMBIT       1               /* Upper left key was down w/key */
 169 #define SYSTEMMASK      0x000100
 170 /* other "bucky" bits can be defined at will.  See "BUCKYBITS" below. */
 171
 172 /*
 173  * This defines the bit positions used within "shiftmask" to
 174  * indicate the "pressed" (1) or "released" (0) state of shift keys.
 175  * Both the bit numbers, and the aggregate masks, are defined.
 176  *
 177  * The "UPMASK" is a minor kludge.  Since whether the key is going
 178  * up or down determines the translation table (just as the shift
 179  * keys' positions do), we OR it with "shiftmask" to get "tempmask",
 180  * which is the mask which is actually used to determine the
 181  * translation table to use.  Don't reassign 0x0080 for anything
 182  * else, or we'll have to shift and such to squeeze in UPMASK,
 183  * since it comes in from the hardware as 0x80.
 184  */
 185 #define CAPSLOCK        0               /* Caps Lock key */
 186 #define CAPSMASK        0x0001
 187 #define SHIFTLOCK       1               /* Shift Lock key */
 188 #define LEFTSHIFT       2               /* Left-hand shift key */
 189 #define RIGHTSHIFT      3               /* Right-hand shift key */
 190 #define SHIFTMASK       0x000E
 191 #define LEFTCTRL        4               /* Left-hand (or only) control key */
 192 #define RIGHTCTRL       5               /* Right-hand control key */
 193 #define CTRLMASK        0x0030
 194 /*      META            6               Meta keys */
 195 /*      META_SHIFT_MASK 0x0040          reserved */
 196 /*      TOP             7               do not use! */
 197 /*      TOPMASK         0x0080          UPMASK in keyboard driver */
 198 /*      CMD             8               reserved */
 199 /*      CMDMASK         0x0100          reserved */
 200 #define ALTGRAPH        9               /* Alt Graph key */
 201 #define ALTGRAPHMASK    0x0200
 202 #define ALT             10              /* Left (or only) Alt key */
 203 #define LEFTALT         10              /* Left Alt key */
 204 #define ALTMASK         0x1400
 205 #define NUMLOCK         11              /* Num Lock key */
 206 #define NUMLOCKMASK     0x0800
 207 #define RIGHTALT        12              /* Right Alt key */
 208 #define UPMASK          0x0080
 209
 210 /*
 211  * This defines the format of translation tables.
 212  *
 213  * A translation table is KEYMAP_SIZE "entries", each of which is 2 bytes
 214  * (unsigned shorts).  The top 8 bits of each entry are decoded by
 215  * a case statement in getkey.c.  If the entry is less than 0x100, it
 216  * is sent out as an EUC character (possibly with bucky bits
 217  * OR-ed in).  "Special" entries are 0x100 or greater, and
 218  * invoke more complicated actions.
 219  *
 220  * The KEYMAP_SIZE is dependent upon the keyboard type.  For example, the
 221  * Sun Type 4/5 keyboards have a KEYMAP_SIZE of 128 where a USB keyboard
 222  * has a KEYMAP_SIZE of 255.  Instead of defining a KEYMAP_SIZE per
 223  * keyboard type, a keyboard specific module/driver may supply the value
 224  * at run time by defining the KEYMAP_SIZE_VARIABLE and filling in the
 225  * keyboard struct appropriately.
 226  */
 227
 228 #ifdef KEYMAP_SIZE_VARIABLE
 229
 230 typedef unsigned short keymap_entry_t;
 231
 232 #else
 233 #define KEYMAP_SIZE     128
 234
 235 struct keymap {
 236         unsigned short  keymap[KEYMAP_SIZE];    /* maps keycodes to actions */
 237 };
 238
 239 #endif
 240
 241 /*
 242  * This structure is used for "exception" cases for key sequences that
 243  * we want to map, that should not be handled by keymap entries (For
 244  * example: using Control-Shift-F1 on PC's for the compose key).
 245  */
 246 struct exception_map {
 247         /*
 248          * these are the modifier keys that we "care" about
 249          */
 250         unsigned int exc_care;
 251
 252         /*
 253          * This is the mask of modifier keys that we want to match
 254          */
 255         unsigned int exc_mask;
 256
 257         /*
 258          * This is the key that we want to match.
 259          */
 260         int exc_key;
 261
 262         /*
 263          * This is our translated version of the matching sequence.
 264          */
 265         unsigned short exc_entry;
 266 };
 267
 268 /*
 269  * A keyboard is defined by its keymaps and what state it resets at idle.
 270  *
 271  * The masks k_idleshifts and k_idlebuckys are AND-ed with the current
 272  * state of  shiftmask  and  buckybits  when a "keyboard idle" code
 273  * is received.  This ensures that where we "think" the shift & bucky
 274  * keys are, more accurately reflects where they really are, since the
 275  * keyboard knows better than us.  However, some keyboards don't know
 276  * about shift states that should be remembered across idles.  Such
 277  * shifts are described by k_toggleshifts.  k_toggleshifts are used to
 278  * identify such shifts.  A toggle shift state is maintained separately
 279  * from the general shift state.  The toggle shift state is OR-ed
 280  * with the state general shift state when an idle is received.
 281  * k_toggleshifts should not appear in the k_up table.
 282  */
 283 struct keyboard {
 284 #ifdef KEYMAP_SIZE_VARIABLE
 285         int             k_keymap_size;  /* Number of entries in keymaps */
 286         keymap_entry_t  *k_normal;      /* Unshifted */
 287         keymap_entry_t  *k_shifted;     /* Shifted */
 288         keymap_entry_t  *k_caps;        /* Caps locked */
 289         keymap_entry_t  *k_altgraph;    /* Alt Graph down */
 290         keymap_entry_t  *k_numlock;     /* Num Lock down */
 291         keymap_entry_t  *k_control;     /* Controlled */
 292         keymap_entry_t  *k_up;          /* Key went up */
 293 #else
 294         struct keymap   *k_normal;      /* Unshifted */
 295         struct keymap   *k_shifted;     /* Shifted */
 296         struct keymap   *k_caps;        /* Caps locked */
 297         struct keymap   *k_altgraph;    /* Alt Graph down */
 298         struct keymap   *k_numlock;     /* Num Lock down */
 299         struct keymap   *k_control;     /* Controlled */
 300         struct keymap   *k_up;          /* Key went up */
 301 #endif
 302         int             k_idleshifts;   /* Shifts that keep across idle */
 303         int             k_idlebuckys;   /* Bucky bits that keep across idle */
 304         unsigned char   k_abort1;       /* 1st key of abort sequence */
 305         unsigned char   k_abort1a;      /* alternate 1st key */
 306         unsigned char   k_abort2;       /* 2nd key of abort sequence */
 307         int             k_toggleshifts; /* Shifts that toggle on down from */
 308                                         /* kbd and keep across idle */
 309         struct exception_map *k_except; /* Oddball cases */
 310         unsigned char   k_newabort1;    /* 1st key of new abort sequence */
 311         unsigned char   k_newabort1a;   /* alternate 1st key */
 312         unsigned char   k_newabort2;    /* 2nd key of new abort sequence */
 313 };
 314
 315 /*
 316  * Define the compose sequence structure.  First and second
 317  * ASCII chars of 0 indicate the end of the table.
 318  */
 319 struct compose_sequence_t {
 320         unsigned char   first;  /* first ASCII char after COMPOSE key */
 321         unsigned char   second; /* second ASCII char after COMPOSE key */
 322         unsigned char   iso;    /* equivalent ISO code */
 323 };
 324
 325 /*
 326  * Define the floating accent sequence structure.
 327  */
 328 struct fltaccent_sequence_t {
 329         unsigned short  fa_entry;       /* floating accent keymap entry */
 330         unsigned char   ascii;          /* ASCII char after FA-type key */
 331         unsigned char   iso;            /* equivalent ISO code */
 332 };
 333
 334 /*
 335  * The "special" entries' top 4 bits are defined below.  Generally they are
 336  * used with a 4-bit parameter (such as a bit number) in the low 4 bits.
 337  * The bytes whose top 4 bits are 0x0 thru 0x7 happen to be ascii
 338  * characters.  They are not special cased, but just normal cased.
 339  */
 340
 341 #define SHIFTKEYS       0x100   /* thru 0x10F.  This key helps to determine */
 342                                 /* the translation table used.  The bit */
 343                                 /* position of its bit in "shiftmask" */
 344                                 /* is added to the entry, eg */
 345                                 /* SHIFTKEYS+LEFTCTRL.  When this entry is */
 346                                 /* invoked, the bit in "shiftmask" is */
 347                                 /* toggled.  Depending which tables you put */
 348                                 /* it in, this works well for hold-down */
 349                                 /* keys or press-on, press-off keys.  */
 350 #define BUCKYBITS       0x200   /* thru 0x20F.  This key determines the state */
 351                                 /* of one of the "bucky" bits above the */
 352                                 /* returned ASCII character.  This is */
 353                                 /* basically a way to pass mode-key-up/down */
 354                                 /* information back to the caller with each */
 355                                 /* "real" key depressed.  The concept, and */
 356                                 /* name "bucky" (derivation unknown) comes */
 357                                 /* from the MIT/SAIL "TV" system...they had */
 358                                 /* TOP, META, CTRL, and a few other bucky */
 359                                 /* bits.  The bit position of its bit in */
 360                                 /* "buckybits", minus 7, is added to the */
 361                                 /* entry; eg bit 0x00000400 is BUCKYBITS+3. */
 362                                 /* The "-7" prevents us from messing up the */
 363                                 /* ASCII char, and gives us 16 useful bucky */
 364                                 /* bits.  When this entry is invoked, */
 365                                 /* the designated bit in "buckybits" is */
 366                                 /* toggled.  Depending which tables you put */
 367                                 /* it in, this works well for hold-down */
 368                                 /* keys or press-on, press-off keys.  */
 369 #define FUNNY           0x300   /* thru 0x30F.  This key does one of 16 funny */
 370                                 /* things based on the low 4 bits: */
 371 #define NOP             0x300   /* This key does nothing. */
 372 #define OOPS            0x301   /* This key exists but is undefined. */
 373 #define HOLE            0x302   /* This key does not exist on the keyboard. */
 374                                 /* Its position code should never be */
 375                                 /* generated.  This indicates a software/ */
 376                                 /* hardware mismatch, or bugs. */
 377 #define RESET           0x306   /* Kbd was just reset */
 378 #define ERROR           0x307   /* Kbd just detected an internal error */
 379 #define IDLE            0x308   /* Kbd is idle (no keys down) */
 380 #define COMPOSE         0x309   /* This key is the Compose key. */
 381 #define NONL            0x30A   /* This key not affected by Num Lock */
 382 /* Combinations 0x30B to 0x30F are reserved for non-parameterized functions */
 383
 384 #define FA_CLASS        0x400   /* thru 0x40F.  These are for "floating */
 385                                 /* accent" characters.  The low-order 4 bits */
 386                                 /* select one of those characters. */
 387 /* Definitions for the individual floating accents: */
 388 #define FA_UMLAUT       0x400   /* umlaut accent */
 389 #define FA_CFLEX        0x401   /* circumflex accent */
 390 #define FA_TILDE        0x402   /* tilde accent */
 391 #define FA_CEDILLA      0x403   /* cedilla accent */
 392 #define FA_ACUTE        0x404   /* acute accent */
 393 #define FA_GRAVE        0x405   /* grave accent */
 394
 395 #define STRING          0x500   /* thru 0x50F.  The low-order 4 bits index */
 396                                 /* a table select a string to be returned, */
 397                                 /* char by char.  Each entry the table is */
 398                                 /* null terminated. */
 399 #define KTAB_STRLEN     10      /* Maximum string length (including null) */
 400 /* Definitions for the individual string numbers: */
 401 #define HOMEARROW       0x00
 402 #define UPARROW         0x01
 403 #define DOWNARROW       0x02
 404 #define LEFTARROW       0x03
 405 #define RIGHTARROW      0x04
 406 /* string numbers 5 thru F are available to users making custom entries */
 407
 408 /*
 409  * In the following function key groupings, the low-order 4 bits indicate
 410  * the function key number within the group, and the next 4 bits indicate
 411  * the group.
 412  */
 413 #define FUNCKEYS        0x600
 414 #define LEFTFUNC        0x600   /* thru 0x60F.  The "left" group. */
 415 #define RIGHTFUNC       0x610   /* thru 0x61F.  The "right" group. */
 416 #define TOPFUNC         0x620   /* thru 0x62F.  The "top" group. */
 417 #define BOTTOMFUNC      0x630   /* thru 0x63F.  The "bottom" group. */
 418 #define LF(n)           (LEFTFUNC+(n)-1)
 419 #define RF(n)           (RIGHTFUNC+(n)-1)
 420 #define TF(n)           (TOPFUNC+(n)-1)
 421 #define BF(n)           (BOTTOMFUNC+(n)-1)
 422
 423 /*
 424  * The actual keyboard positions may not be on the left/right/top/bottom
 425  * of the physical keyboard (although they usually are).
 426  * What is important is that we have reserved 64 keys for function keys.
 427  *
 428  * Normally, striking a function key will cause the following escape sequence
 429  * to be sent through the character stream:
 430  *      ESC[0..9z
 431  * where ESC is a single escape character and 0..9 indicate some number of
 432  * digits needed to encode the function key as a decimal number.
 433  */
 434 #define PADKEYS         0x700
 435 #define PADEQUAL        0x700           /* keypad = */
 436 #define PADSLASH        0x701           /* keypad / */
 437 #define PADSTAR         0x702           /* keypad * */
 438 #define PADMINUS        0x703           /* keypad - */
 439 #define PADSEP          0x704           /* keypad,  */
 440 #define PAD7            0x705           /* keypad 7 */
 441 #define PAD8            0x706           /* keypad 8 */
 442 #define PAD9            0x707           /* keypad 9 */
 443 #define PADPLUS         0x708           /* keypad + */
 444 #define PAD4            0x709           /* keypad 4 */
 445 #define PAD5            0x70A           /* keypad 5 */
 446 #define PAD6            0x70B           /* keypad 6 */
 447 #define PAD1            0x70C           /* keypad 1 */
 448 #define PAD2            0x70D           /* keypad 2 */
 449 #define PAD3            0x70E           /* keypad 3 */
 450 #define PAD0            0x70F           /* keypad 0 */
 451 #define PADDOT          0x710           /* keypad . */
 452 #define PADENTER        0x711           /* keypad Enter */
 453
 454 #ifdef  __cplusplus
 455 }
 456 #endif
 457
 458 #endif  /* _SYS_KBD_H */