Changeset 1235164 in rtems


Ignore:
Timestamp:
Sep 10, 2007, 2:27:46 PM (12 years ago)
Author:
Joel Sherrill <joel.sherrill@…>
Branches:
4.10, 4.11, 4.8, 4.9, master
Children:
c613270
Parents:
891a8254
Message:

2007-09-10 Joel Sherrill <joel.sherrill@…>

  • console/keyboard.c: Replaced tabs with spaces.
Location:
c/src/lib/libbsp/i386/pc386
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • c/src/lib/libbsp/i386/pc386/ChangeLog

    r891a8254 r1235164  
     12007-09-10      Joel Sherrill <joel.sherrill@OARcorp.com>
     2
     3        * console/keyboard.c: Replaced tabs with spaces.
     4
    152007-09-07      Joel Sherrill <joel.sherrill@oarcorp.com>
    26
  • c/src/lib/libbsp/i386/pc386/console/keyboard.c

    r891a8254 r1235164  
    3535int set_bit(int nr, unsigned long * addr)
    3636{
    37         int     mask, retval,level;
    38 
    39         addr += nr >> 5;
    40         mask = 1 << (nr & 0x1f);
    41         _CPU_ISR_Disable(level)
    42         retval = (mask & *addr) != 0;
    43         *addr |= mask;
    44         _CPU_ISR_Enable (level);
    45         return retval;
     37  int  mask, retval,level;
     38
     39  addr += nr >> 5;
     40  mask = 1 << (nr & 0x1f);
     41  _CPU_ISR_Disable(level)
     42  retval = (mask & *addr) != 0;
     43  *addr |= mask;
     44  _CPU_ISR_Enable (level);
     45  return retval;
    4646}
    4747
    4848int clear_bit(int nr, unsigned long * addr)
    4949{
    50         int     mask, retval,level;
    51 
    52         addr += nr >> 5;
    53         mask = 1 << (nr & 0x1f);
    54         _CPU_ISR_Disable(level)
    55         retval = (mask & *addr) != 0;
    56         *addr &= ~mask;
    57         _CPU_ISR_Enable (level);
    58         return retval;
     50  int  mask, retval,level;
     51
     52  addr += nr >> 5;
     53  mask = 1 << (nr & 0x1f);
     54  _CPU_ISR_Disable(level)
     55  retval = (mask & *addr) != 0;
     56  *addr &= ~mask;
     57  _CPU_ISR_Enable (level);
     58  return retval;
    5959}
    6060
    6161int test_bit(int nr, unsigned long * addr)
    6262{
    63         int     mask;
    64 
    65         addr += nr >> 5;
    66         mask = 1 << (nr & 0x1f);
    67         return ((mask & *addr) != 0);
     63  int  mask;
     64
     65  addr += nr >> 5;
     66  mask = 1 << (nr & 0x1f);
     67  return ((mask & *addr) != 0);
    6868}
    6969
     
    9090 */
    9191int shift_state = 0;
    92 static int npadch = -1;                 /* -1 or number assembled on pad */
     92static int npadch = -1;      /* -1 or number assembled on pad */
    9393static unsigned char diacr = 0;
    94 static char rep = 0;                    /* flag telling character repeat */
     94static char rep = 0;      /* flag telling character repeat */
    9595
    9696/* default console for RTEMS */
     
    106106
    107107static k_handfn
    108         do_self, do_fn, do_spec, do_pad, do_dead, do_cons, do_cur, do_shift,
    109         do_meta, do_ascii, do_lock, do_lowercase, do_slock, do_dead2,
    110         do_ignore;
     108  do_self, do_fn, do_spec, do_pad, do_dead, do_cons, do_cur, do_shift,
     109  do_meta, do_ascii, do_lock, do_lowercase, do_slock, do_dead2,
     110  do_ignore;
    111111
    112112static k_hand key_handler[16] = {
    113         do_self, do_fn, do_spec, do_pad, do_dead, do_cons, do_cur, do_shift,
    114         do_meta, do_ascii, do_lock, do_lowercase, do_slock, do_dead2,
    115         do_ignore, do_ignore
     113  do_self, do_fn, do_spec, do_pad, do_dead, do_cons, do_cur, do_shift,
     114  do_meta, do_ascii, do_lock, do_lowercase, do_slock, do_dead2,
     115  do_ignore, do_ignore
    116116};
    117117
     
    131131
    132132static void_fn do_null, enter, show_ptregs, send_intr, lastcons, caps_toggle,
    133         num, hold, scroll_forw, scroll_back, boot_it, caps_on, compose,
    134         SAK, decr_console, incr_console, spawn_console, bare_num;
     133  num, hold, scroll_forw, scroll_back, boot_it, caps_on, compose,
     134  SAK, decr_console, incr_console, spawn_console, bare_num;
    135135
    136136static void_fnp spec_fn_table[] = {
    137         do_null,        enter,          show_ptregs,    show_mem,
    138         show_state,     send_intr,      lastcons,       caps_toggle,
    139         num,            hold,           scroll_forw,    scroll_back,
    140         boot_it,        caps_on,        compose,        SAK,
    141         decr_console,   incr_console,   spawn_console,  bare_num
     137  do_null,  enter,    show_ptregs,  show_mem,
     138  show_state,  send_intr,  lastcons,  caps_toggle,
     139  num,    hold,    scroll_forw,  scroll_back,
     140  boot_it,  caps_on,  compose,  SAK,
     141  decr_console,  incr_console,  spawn_console,  bare_num
    142142};
    143143
     
    146146/* maximum values each key_handler can handle */
    147147const int max_vals[] = {
    148         255, SIZE(func_table) - 1, SIZE(spec_fn_table) - 1, NR_PAD - 1,
    149         NR_DEAD - 1, 255, 3, NR_SHIFT - 1,
    150         255, NR_ASCII - 1, NR_LOCK - 1, 255,
    151         NR_LOCK - 1, 255
     148  255, SIZE(func_table) - 1, SIZE(spec_fn_table) - 1, NR_PAD - 1,
     149  NR_DEAD - 1, 255, 3, NR_SHIFT - 1,
     150  255, NR_ASCII - 1, NR_LOCK - 1, 255,
     151  NR_LOCK - 1, 255
    152152};
    153153
     
    170170void to_utf8(ushort c) {
    171171    if (c < 0x80)
    172         put_queue(c);                   /*  0*******  */
     172  put_queue(c);      /*  0*******  */
    173173    else if (c < 0x800) {
    174         put_queue(0xc0 | (c >> 6));     /*  110***** 10******  */
    175         put_queue(0x80 | (c & 0x3f));
     174  put_queue(0xc0 | (c >> 6));   /*  110***** 10******  */
     175  put_queue(0x80 | (c & 0x3f));
    176176    } else {
    177         put_queue(0xe0 | (c >> 12));    /*  1110**** 10****** 10******  */
    178         put_queue(0x80 | ((c >> 6) & 0x3f));
    179         put_queue(0x80 | (c & 0x3f));
     177  put_queue(0xe0 | (c >> 12));   /*  1110**** 10****** 10******  */
     178  put_queue(0x80 | ((c >> 6) & 0x3f));
     179  put_queue(0x80 | (c & 0x3f));
    180180    }
    181181    /* UTF-8 is defined for words of up to 31 bits,
     
    200200void handle_scancode(unsigned char scancode, int down)
    201201{
    202         unsigned char keycode;
    203         char up_flag = down ? 0 : 0200;
    204         char raw_mode;
    205 
    206         mark_bh(CONSOLE_BH);
     202  unsigned char keycode;
     203  char up_flag = down ? 0 : 0200;
     204  char raw_mode;
     205
     206  mark_bh(CONSOLE_BH);
    207207
    208208#if 0
    209         tty = ttytab? ttytab[fg_console]: NULL;
    210         if (tty && (!tty->driver_data)) {
    211                 /*
    212                 * We touch the tty structure via the the ttytab array
    213                 * without knowing whether or not tty is open, which
    214                 * is inherently dangerous.  We currently rely on that
    215                 * fact that console_open sets tty->driver_data when
    216                 * it opens it, and clears it when it closes it.
    217                 */
    218                 tty = NULL;
    219         }
     209  tty = ttytab? ttytab[fg_console]: NULL;
     210  if (tty && (!tty->driver_data)) {
     211    /*
     212    * We touch the tty structure via the the ttytab array
     213    * without knowing whether or not tty is open, which
     214    * is inherently dangerous.  We currently rely on that
     215    * fact that console_open sets tty->driver_data when
     216    * it opens it, and clears it when it closes it.
     217    */
     218    tty = NULL;
     219  }
    220220#endif
    221221
    222         kbd = kbd_table + fg_console;
    223         if ((raw_mode = (kbd->kbdmode == VC_RAW))) {
    224                 put_queue(scancode | up_flag);
    225                 /* we do not return yet, because we want to maintain
    226                    the key_down array, so that we have the correct
    227                    values when finishing RAW mode or when changing VT's */
    228         }
    229 
    230         /*
    231         *  Convert scancode to keycode
    232         */
    233         if (!kbd_translate(scancode, &keycode, raw_mode))
    234             return;
    235 
    236         /*
    237         * At this point the variable `keycode' contains the keycode.
    238         * Note: the keycode must not be 0 (++Geert: on m68k 0 is valid).
    239         * We keep track of the up/down status of the key, and
    240         * return the keycode if in MEDIUMRAW mode.
    241         */
    242 
    243         if (up_flag) {
    244                 rep = 0;
    245                 if(!test_and_clear_bit(keycode, key_down))
    246                     up_flag = kbd_unexpected_up(keycode);
    247         } else
    248                 rep = test_and_set_bit(keycode, key_down);
    249 
    250 #ifdef CONFIG_MAGIC_SYSRQ               /* Handle the SysRq Hack */
    251         if (keycode == SYSRQ_KEY) {
    252                 sysrq_pressed = !up_flag;
    253                 return;
    254         } else if (sysrq_pressed) {
    255                 if (!up_flag && sysrq_enabled)
    256                         handle_sysrq(kbd_sysrq_xlate[keycode], kbd_pt_regs, kbd, tty);
    257                 return;
    258         }
     222  kbd = kbd_table + fg_console;
     223  if ((raw_mode = (kbd->kbdmode == VC_RAW))) {
     224    put_queue(scancode | up_flag);
     225    /* we do not return yet, because we want to maintain
     226       the key_down array, so that we have the correct
     227       values when finishing RAW mode or when changing VT's */
     228  }
     229
     230  /*
     231  *  Convert scancode to keycode
     232  */
     233  if (!kbd_translate(scancode, &keycode, raw_mode))
     234      return;
     235
     236  /*
     237  * At this point the variable `keycode' contains the keycode.
     238  * Note: the keycode must not be 0 (++Geert: on m68k 0 is valid).
     239  * We keep track of the up/down status of the key, and
     240  * return the keycode if in MEDIUMRAW mode.
     241  */
     242
     243  if (up_flag) {
     244    rep = 0;
     245    if(!test_and_clear_bit(keycode, key_down))
     246        up_flag = kbd_unexpected_up(keycode);
     247  } else
     248    rep = test_and_set_bit(keycode, key_down);
     249
     250#ifdef CONFIG_MAGIC_SYSRQ    /* Handle the SysRq Hack */
     251  if (keycode == SYSRQ_KEY) {
     252    sysrq_pressed = !up_flag;
     253    return;
     254  } else if (sysrq_pressed) {
     255    if (!up_flag && sysrq_enabled)
     256      handle_sysrq(kbd_sysrq_xlate[keycode], kbd_pt_regs, kbd, tty);
     257    return;
     258  }
    259259#endif
    260260
    261         if (kbd->kbdmode == VC_MEDIUMRAW) {
    262                 /* soon keycodes will require more than one byte */
    263                 put_queue(keycode + up_flag);
    264                 raw_mode = 1;   /* Most key classes will be ignored */
    265         }
    266         /*
    267         * Small change in philosophy: earlier we defined repetition by
    268          *      rep = keycode == prev_keycode;
    269          *      prev_keycode = keycode;
    270         * but now by the fact that the depressed key was down already.
    271         * Does this ever make a difference? Yes.
    272         */
    273 
    274         /*
    275         *  Repeat a key only if the input buffers are empty or the
    276         *  characters get echoed locally. This makes key repeat usable
    277         *  with slow applications and under heavy loads.
    278         */
    279         if (!rep || vc_kbd_mode(kbd,VC_REPEAT) ) {
    280 /*
    281         ||  (vc_kbd_mode(kbd,VC_REPEAT) && tty &&
    282              (L_ECHO(tty) || (tty->driver.chars_in_buffer(tty) == 0)))) {
     261  if (kbd->kbdmode == VC_MEDIUMRAW) {
     262    /* soon keycodes will require more than one byte */
     263    put_queue(keycode + up_flag);
     264    raw_mode = 1;  /* Most key classes will be ignored */
     265  }
     266  /*
     267  * Small change in philosophy: earlier we defined repetition by
     268   *  rep = keycode == prev_keycode;
     269   *  prev_keycode = keycode;
     270  * but now by the fact that the depressed key was down already.
     271  * Does this ever make a difference? Yes.
     272  */
     273
     274  /*
     275  *  Repeat a key only if the input buffers are empty or the
     276  *  characters get echoed locally. This makes key repeat usable
     277  *  with slow applications and under heavy loads.
     278  */
     279  if (!rep || vc_kbd_mode(kbd,VC_REPEAT) ) {
     280/*
     281  ||  (vc_kbd_mode(kbd,VC_REPEAT) && tty &&
     282       (L_ECHO(tty) || (tty->driver.chars_in_buffer(tty) == 0)))) {
    283283*/
    284                 u_short keysym;
    285                 u_char type;
    286 
    287                 /* the XOR below used to be an OR */
    288                 int shift_final = shift_state ^ kbd->lockstate ^ kbd->slockstate;
    289                 ushort *key_map = key_maps[shift_final];
    290 
    291                 if (key_map != NULL) {
    292                         keysym = key_map[keycode];
    293                         type = KTYP(keysym);
    294 
    295                         if (type >= 0xf0) {
    296                             type -= 0xf0;
    297                             if (raw_mode && ! (TYPES_ALLOWED_IN_RAW_MODE & (1 << type)))
    298                                 return;
    299                     if (type == KT_LETTER) {
    300                                 type = KT_LATIN;
    301                                 if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
    302                                     key_map = key_maps[shift_final ^ (1<<KG_SHIFT)];
    303                                     if (key_map)
    304                                       keysym = key_map[keycode];
    305                                 }
    306                             }
    307 
    308                             (*key_handler[type])(keysym & 0xff, up_flag);
    309 
    310                             if (type != KT_SLOCK)
    311                               kbd->slockstate = 0;
    312 
    313                         } else {
    314                             /* maybe only if (kbd->kbdmode == VC_UNICODE) ? */
    315                             if (!up_flag && !raw_mode)
    316                               to_utf8(keysym);
    317                         }
    318                 } else {
    319                         /* maybe beep? */
    320                         /* we have at least to update shift_state */
    321 #if 1                   /* how? two almost equivalent choices follow */
    322                         compute_shiftstate();
     284    u_short keysym;
     285    u_char type;
     286
     287    /* the XOR below used to be an OR */
     288    int shift_final = shift_state ^ kbd->lockstate ^ kbd->slockstate;
     289    ushort *key_map = key_maps[shift_final];
     290
     291    if (key_map != NULL) {
     292      keysym = key_map[keycode];
     293      type = KTYP(keysym);
     294
     295      if (type >= 0xf0) {
     296          type -= 0xf0;
     297          if (raw_mode && ! (TYPES_ALLOWED_IN_RAW_MODE & (1 << type)))
     298        return;
     299         if (type == KT_LETTER) {
     300        type = KT_LATIN;
     301        if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
     302            key_map = key_maps[shift_final ^ (1<<KG_SHIFT)];
     303            if (key_map)
     304              keysym = key_map[keycode];
     305        }
     306          }
     307
     308          (*key_handler[type])(keysym & 0xff, up_flag);
     309
     310          if (type != KT_SLOCK)
     311            kbd->slockstate = 0;
     312
     313      } else {
     314          /* maybe only if (kbd->kbdmode == VC_UNICODE) ? */
     315          if (!up_flag && !raw_mode)
     316            to_utf8(keysym);
     317      }
     318    } else {
     319      /* maybe beep? */
     320      /* we have at least to update shift_state */
     321#if 1      /* how? two almost equivalent choices follow */
     322      compute_shiftstate();
    323323#else
    324                         keysym = U(plain_map[keycode]);
    325                         type = KTYP(keysym);
    326                         if (type == KT_SHIFT)
    327                           (*key_handler[type])(keysym & 0xff, up_flag);
     324      keysym = U(plain_map[keycode]);
     325      type = KTYP(keysym);
     326      if (type == KT_SHIFT)
     327        (*key_handler[type])(keysym & 0xff, up_flag);
    328328#endif
    329                 }
    330         }
     329    }
     330  }
    331331}
    332332
     
    353353static void puts_queue(char *cp)
    354354{
    355         while (*cp) {
     355  while (*cp) {
    356356     put_queue( *cp );
    357                 cp++;
    358         }
     357    cp++;
     358  }
    359359}
    360360
    361361static void applkey(int key, char mode)
    362362{
    363         static char buf[] = { 0x1b, 'O', 0x00, 0x00 };
    364 
    365         buf[1] = (mode ? 'O' : '[');
    366         buf[2] = key;
    367         puts_queue(buf);
     363  static char buf[] = { 0x1b, 'O', 0x00, 0x00 };
     364
     365  buf[1] = (mode ? 'O' : '[');
     366  buf[2] = key;
     367  puts_queue(buf);
    368368}
    369369
    370370static void enter(void)
    371371{
    372         if (diacr) {
    373                 put_queue(diacr);
    374                 diacr = 0;
    375         }
    376         put_queue(13);
    377 
    378         if (vc_kbd_mode(kbd,VC_CRLF))
    379                 put_queue(10);
     372  if (diacr) {
     373    put_queue(diacr);
     374    diacr = 0;
     375  }
     376  put_queue(13);
     377
     378  if (vc_kbd_mode(kbd,VC_CRLF))
     379    put_queue(10);
    380380
    381381}
     
    383383static void caps_toggle(void)
    384384{
    385         if (rep)
    386                 return;
    387         chg_vc_kbd_led(kbd, VC_CAPSLOCK);
     385  if (rep)
     386    return;
     387  chg_vc_kbd_led(kbd, VC_CAPSLOCK);
    388388}
    389389
    390390static void caps_on(void)
    391391{
    392         if (rep)
    393                 return;
    394         set_vc_kbd_led(kbd, VC_CAPSLOCK);
     392  if (rep)
     393    return;
     394  set_vc_kbd_led(kbd, VC_CAPSLOCK);
    395395}
    396396
     
    401401static void hold(void)
    402402{
    403         if (rep )
    404                 return;
     403  if (rep )
     404    return;
    405405   chg_vc_kbd_led(kbd, VC_SCROLLOCK );
    406406
     
    410410{
    411411
    412         if (vc_kbd_mode(kbd,VC_APPLIC))
    413                 applkey('P', 1);
    414         else
    415                 bare_num();
     412  if (vc_kbd_mode(kbd,VC_APPLIC))
     413    applkey('P', 1);
     414  else
     415    bare_num();
    416416}
    417417
     
    424424static void bare_num(void)
    425425{
    426         if (!rep)
    427                 chg_vc_kbd_led(kbd,VC_NUMLOCK);
     426  if (!rep)
     427    chg_vc_kbd_led(kbd,VC_NUMLOCK);
    428428}
    429429
     
    460460static void compose(void)
    461461{
    462         dead_key_next = 1;
     462  dead_key_next = 1;
    463463}
    464464
     
    479479static void do_null()
    480480{
    481         compute_shiftstate();
     481  compute_shiftstate();
    482482}
    483483
    484484static void do_spec(unsigned char value, char up_flag)
    485485{
    486         if (up_flag)
    487                 return;
    488         if (value >= SIZE(spec_fn_table))
    489                 return;
    490 
    491         if ((kbd->kbdmode == VC_RAW || kbd->kbdmode == VC_MEDIUMRAW) &&
    492             !(SPECIALS_ALLOWED_IN_RAW_MODE & (1 << value)))
    493                 return;
    494 
    495         spec_fn_table[value]();
     486  if (up_flag)
     487    return;
     488  if (value >= SIZE(spec_fn_table))
     489    return;
     490
     491  if ((kbd->kbdmode == VC_RAW || kbd->kbdmode == VC_MEDIUMRAW) &&
     492      !(SPECIALS_ALLOWED_IN_RAW_MODE & (1 << value)))
     493    return;
     494
     495  spec_fn_table[value]();
    496496}
    497497
     
    502502static void do_self(unsigned char value, char up_flag)
    503503{
    504         if (up_flag)
    505                 return;         /* no action, if this is a key release */
    506 
    507         if (diacr)
    508                 value = handle_diacr(value);
    509 
    510         if (dead_key_next) {
    511                 dead_key_next = 0;
    512                 diacr = value;
    513                 return;
    514         }
    515         put_queue(value);
     504  if (up_flag)
     505    return;    /* no action, if this is a key release */
     506
     507  if (diacr)
     508    value = handle_diacr(value);
     509
     510  if (dead_key_next) {
     511    dead_key_next = 0;
     512    diacr = value;
     513    return;
     514  }
     515  put_queue(value);
    516516}
    517517
     
    523523#define A_CEDIL  ','
    524524static unsigned char ret_diacr[NR_DEAD] =
    525         {A_GRAVE, A_ACUTE, A_CFLEX, A_TILDE, A_DIAER, A_CEDIL };
     525  {A_GRAVE, A_ACUTE, A_CFLEX, A_TILDE, A_DIAER, A_CEDIL };
    526526
    527527/* Obsolete - for backwards compatibility only */
    528528static void do_dead(unsigned char value, char up_flag)
    529529{
    530         value = ret_diacr[value];
     530  value = ret_diacr[value];
    531531   printk( " do_dead( %X ) ", value );
    532         do_dead2(value,up_flag);
     532  do_dead2(value,up_flag);
    533533}
    534534
     
    540540static void do_dead2(unsigned char value, char up_flag)
    541541{
    542         if (up_flag)
    543                 return;
    544         diacr = (diacr ? handle_diacr(value) : value);
     542  if (up_flag)
     543    return;
     544  diacr = (diacr ? handle_diacr(value) : value);
    545545}
    546546
     
    554554unsigned char handle_diacr(unsigned char ch)
    555555{
    556         int d = diacr;
    557         int i;
    558 
    559         diacr = 0;
    560 
    561         for (i = 0; i < accent_table_size; i++) {
    562                 if (accent_table[i].diacr == d && accent_table[i].base == ch)
    563                         return accent_table[i].result;
    564         }
    565         if (ch == ' ' || ch == d)
    566                 return d;
    567 
    568         put_queue(d);
    569         return ch;
     556  int d = diacr;
     557  int i;
     558
     559  diacr = 0;
     560
     561  for (i = 0; i < accent_table_size; i++) {
     562    if (accent_table[i].diacr == d && accent_table[i].base == ch)
     563      return accent_table[i].result;
     564  }
     565  if (ch == ' ' || ch == d)
     566    return d;
     567
     568  put_queue(d);
     569  return ch;
    570570}
    571571
    572572static void do_cons(unsigned char value, char up_flag)
    573573{
    574         if (up_flag)
    575                 return;
     574  if (up_flag)
     575    return;
    576576}
    577577
    578578static void do_fn(unsigned char value, char up_flag)
    579579{
    580         if (up_flag)
    581                 return;
    582 
    583         if (value < SIZE(func_table)) {
    584                 if (func_table[value])
    585                         puts_queue(func_table[value]);
    586         } else
    587                 printk( "do_fn called with value=%d\n", value);
     580  if (up_flag)
     581    return;
     582
     583  if (value < SIZE(func_table)) {
     584    if (func_table[value])
     585      puts_queue(func_table[value]);
     586  } else
     587    printk( "do_fn called with value=%d\n", value);
    588588}
    589589
    590590static void do_pad(unsigned char value, char up_flag)
    591591{
    592         static const char *pad_chars = "0123456789+-*/\015,.?()";
    593         static const char *app_map = "pqrstuvwxylSRQMnnmPQ";
    594 
    595         if (up_flag)
    596                 return;         /* no action, if this is a key release */
    597 
    598         /* kludge... shift forces cursor/number keys */
    599         if (vc_kbd_mode(kbd,VC_APPLIC) && !k_down[KG_SHIFT]) {
    600                 applkey(app_map[value], 1);
    601                 return;
    602         }
    603         if (!vc_kbd_led(kbd,VC_NUMLOCK))
    604                 switch (value) {
    605                         case KVAL(K_PCOMMA):
    606                         case KVAL(K_PDOT):
    607                                 do_fn(KVAL(K_REMOVE), 0);
    608                                 return;
    609                         case KVAL(K_P0):
    610                                 do_fn(KVAL(K_INSERT), 0);
    611                                 return;
    612                         case KVAL(K_P1):
    613                                 do_fn(KVAL(K_SELECT), 0);
    614                                 return;
    615                         case KVAL(K_P2):
    616                                 do_cur(KVAL(K_DOWN), 0);
    617                                 return;
    618                         case KVAL(K_P3):
    619                                 do_fn(KVAL(K_PGDN), 0);
    620                                 return;
    621                         case KVAL(K_P4):
    622                                 do_cur(KVAL(K_LEFT), 0);
    623                                 return;
    624                         case KVAL(K_P6):
    625                                 do_cur(KVAL(K_RIGHT), 0);
    626                                 return;
    627                         case KVAL(K_P7):
    628                                 do_fn(KVAL(K_FIND), 0);
    629                                 return;
    630                         case KVAL(K_P8):
    631                                 do_cur(KVAL(K_UP), 0);
    632                                 return;
    633                         case KVAL(K_P9):
    634                                 do_fn(KVAL(K_PGUP), 0);
    635                                 return;
    636                         case KVAL(K_P5):
    637                                 applkey('G', vc_kbd_mode(kbd, VC_APPLIC));
    638                                 return;
    639                 }
    640 
    641         put_queue(pad_chars[value]);
    642 
    643         if (value == KVAL(K_PENTER) && vc_kbd_mode(kbd, VC_CRLF))
    644                 put_queue(10);
     592  static const char *pad_chars = "0123456789+-*/\015,.?()";
     593  static const char *app_map = "pqrstuvwxylSRQMnnmPQ";
     594
     595  if (up_flag)
     596    return;    /* no action, if this is a key release */
     597
     598  /* kludge... shift forces cursor/number keys */
     599  if (vc_kbd_mode(kbd,VC_APPLIC) && !k_down[KG_SHIFT]) {
     600    applkey(app_map[value], 1);
     601    return;
     602  }
     603  if (!vc_kbd_led(kbd,VC_NUMLOCK))
     604    switch (value) {
     605      case KVAL(K_PCOMMA):
     606      case KVAL(K_PDOT):
     607        do_fn(KVAL(K_REMOVE), 0);
     608        return;
     609      case KVAL(K_P0):
     610        do_fn(KVAL(K_INSERT), 0);
     611        return;
     612      case KVAL(K_P1):
     613        do_fn(KVAL(K_SELECT), 0);
     614        return;
     615      case KVAL(K_P2):
     616        do_cur(KVAL(K_DOWN), 0);
     617        return;
     618      case KVAL(K_P3):
     619        do_fn(KVAL(K_PGDN), 0);
     620        return;
     621      case KVAL(K_P4):
     622        do_cur(KVAL(K_LEFT), 0);
     623        return;
     624      case KVAL(K_P6):
     625        do_cur(KVAL(K_RIGHT), 0);
     626        return;
     627      case KVAL(K_P7):
     628        do_fn(KVAL(K_FIND), 0);
     629        return;
     630      case KVAL(K_P8):
     631        do_cur(KVAL(K_UP), 0);
     632        return;
     633      case KVAL(K_P9):
     634        do_fn(KVAL(K_PGUP), 0);
     635        return;
     636      case KVAL(K_P5):
     637        applkey('G', vc_kbd_mode(kbd, VC_APPLIC));
     638        return;
     639    }
     640
     641  put_queue(pad_chars[value]);
     642
     643  if (value == KVAL(K_PENTER) && vc_kbd_mode(kbd, VC_CRLF))
     644    put_queue(10);
    645645
    646646}
     
    648648static void do_cur(unsigned char value, char up_flag)
    649649{
    650         static const char *cur_chars = "BDCA";
    651         if (up_flag)
    652                 return;
     650  static const char *cur_chars = "BDCA";
     651  if (up_flag)
     652    return;
    653653
    654654  applkey(cur_chars[value], vc_kbd_mode(kbd,VC_CKMODE));
     
    657657static void do_shift(unsigned char value, char up_flag)
    658658{
    659         int old_state = shift_state;
    660 
    661         if (rep)
    662                 return;
    663 
    664         /* Mimic typewriter:
    665            a CapsShift key acts like Shift but undoes CapsLock */
    666         if (value == KVAL(K_CAPSSHIFT)) {
    667                 value = KVAL(K_SHIFT);
    668                 if (!up_flag)
    669                         clr_vc_kbd_led(kbd, VC_CAPSLOCK);
    670         }
    671 
    672         if (up_flag) {
    673                 /* handle the case that two shift or control
    674                    keys are depressed simultaneously */
    675                 if (k_down[value])
    676                         k_down[value]--;
    677         } else
    678                 k_down[value]++;
    679 
    680         if (k_down[value])
    681                 shift_state |= (1 << value);
    682         else
    683                 shift_state &= ~ (1 << value);
    684 
    685         /* kludge */
    686         if (up_flag && shift_state != old_state && npadch != -1) {
    687                 if (kbd->kbdmode == VC_UNICODE)
    688                   to_utf8(npadch & 0xffff);
    689                 else
    690            put_queue(npadch & 0xff);
    691                 npadch = -1;
    692         }
     659  int old_state = shift_state;
     660
     661  if (rep)
     662    return;
     663
     664  /* Mimic typewriter:
     665     a CapsShift key acts like Shift but undoes CapsLock */
     666  if (value == KVAL(K_CAPSSHIFT)) {
     667    value = KVAL(K_SHIFT);
     668    if (!up_flag)
     669      clr_vc_kbd_led(kbd, VC_CAPSLOCK);
     670  }
     671
     672  if (up_flag) {
     673    /* handle the case that two shift or control
     674       keys are depressed simultaneously */
     675    if (k_down[value])
     676      k_down[value]--;
     677  } else
     678    k_down[value]++;
     679
     680  if (k_down[value])
     681    shift_state |= (1 << value);
     682  else
     683    shift_state &= ~ (1 << value);
     684
     685  /* kludge */
     686  if (up_flag && shift_state != old_state && npadch != -1) {
     687    if (kbd->kbdmode == VC_UNICODE)
     688      to_utf8(npadch & 0xffff);
     689    else
     690     put_queue(npadch & 0xff);
     691    npadch = -1;
     692  }
    693693}
    694694
     
    698698void compute_shiftstate(void)
    699699{
    700         int i, j, k, sym, val;
    701 
    702         shift_state = 0;
    703         for(i=0; i < SIZE(k_down); i++)
    704           k_down[i] = 0;
    705 
    706         for(i=0; i < SIZE(key_down); i++)
    707           if(key_down[i]) {     /* skip this word if not a single bit on */
    708             k = i*BITS_PER_LONG;
    709             for(j=0; j<BITS_PER_LONG; j++,k++)
    710               if(test_bit(k, key_down)) {
    711                 sym = U(plain_map[k]);
    712                 if(KTYP(sym) == KT_SHIFT) {
    713                   val = KVAL(sym);
    714                   if (val == KVAL(K_CAPSSHIFT))
    715                     val = KVAL(K_SHIFT);
    716                   k_down[val]++;
    717                   shift_state |= (1<<val);
    718                 }
    719               }
    720           }
     700  int i, j, k, sym, val;
     701
     702  shift_state = 0;
     703  for(i=0; i < SIZE(k_down); i++)
     704    k_down[i] = 0;
     705
     706  for(i=0; i < SIZE(key_down); i++)
     707    if(key_down[i]) {  /* skip this word if not a single bit on */
     708      k = i*BITS_PER_LONG;
     709      for(j=0; j<BITS_PER_LONG; j++,k++)
     710        if(test_bit(k, key_down)) {
     711    sym = U(plain_map[k]);
     712    if(KTYP(sym) == KT_SHIFT) {
     713      val = KVAL(sym);
     714      if (val == KVAL(K_CAPSSHIFT))
     715        val = KVAL(K_SHIFT);
     716      k_down[val]++;
     717      shift_state |= (1<<val);
     718    }
     719        }
     720    }
    721721}
    722722
    723723static void do_meta(unsigned char value, char up_flag)
    724724{
    725         if (up_flag)
    726                 return;
    727 
    728         if (vc_kbd_mode(kbd, VC_META)) {
    729                 put_queue('\033');
    730                 put_queue(value);
    731         } else
    732                 put_queue(value | 0x80);
     725  if (up_flag)
     726    return;
     727
     728  if (vc_kbd_mode(kbd, VC_META)) {
     729    put_queue('\033');
     730    put_queue(value);
     731  } else
     732    put_queue(value | 0x80);
    733733}
    734734
    735735static void do_ascii(unsigned char value, char up_flag)
    736736{
    737         int base;
    738 
    739         if (up_flag)
    740                 return;
    741 
    742         if (value < 10)    /* decimal input of code, while Alt depressed */
    743             base = 10;
    744         else {       /* hexadecimal input of code, while AltGr depressed */
    745             value -= 10;
    746             base = 16;
    747         }
    748 
    749         if (npadch == -1)
    750           npadch = value;
    751         else
    752           npadch = npadch * base + value;
     737  int base;
     738
     739  if (up_flag)
     740    return;
     741
     742  if (value < 10)    /* decimal input of code, while Alt depressed */
     743      base = 10;
     744  else {       /* hexadecimal input of code, while AltGr depressed */
     745      value -= 10;
     746      base = 16;
     747  }
     748
     749  if (npadch == -1)
     750    npadch = value;
     751  else
     752    npadch = npadch * base + value;
    753753}
    754754
    755755static void do_lock(unsigned char value, char up_flag)
    756756{
    757         if (up_flag || rep)
    758                 return;
    759         chg_vc_kbd_lock(kbd, value);
     757  if (up_flag || rep)
     758    return;
     759  chg_vc_kbd_lock(kbd, value);
    760760}
    761761
    762762static void do_slock(unsigned char value, char up_flag)
    763763{
    764         if (up_flag || rep)
    765                 return;
     764  if (up_flag || rep)
     765    return;
    766766
    767767  chg_vc_kbd_slock(kbd, value);
     
    783783void setledstate(struct kbd_struct *kbd, unsigned int led) {
    784784    if (!(led & ~7)) {
    785         ledioctl = led;
    786         kbd->ledmode = LED_SHOW_IOCTL;
     785  ledioctl = led;
     786  kbd->ledmode = LED_SHOW_IOCTL;
    787787    } else
    788788    ;
    789         kbd->ledmode = LED_SHOW_FLAGS;
     789  kbd->ledmode = LED_SHOW_FLAGS;
    790790    set_leds();
    791791}
     
    798798
    799799void register_leds(int console, unsigned int led,
    800                    unsigned int *addr, unsigned int mask) {
     800       unsigned int *addr, unsigned int mask) {
    801801    struct kbd_struct *kbd = kbd_table + console;
    802802
    803803   if (led < 3) {
    804         ledptrs[led].addr = addr;
    805         ledptrs[led].mask = mask;
    806         ledptrs[led].valid = 1;
    807         kbd->ledmode = LED_SHOW_MEM;
     804  ledptrs[led].addr = addr;
     805  ledptrs[led].mask = mask;
     806  ledptrs[led].valid = 1;
     807  kbd->ledmode = LED_SHOW_MEM;
    808808    } else
    809         kbd->ledmode = LED_SHOW_FLAGS;
     809  kbd->ledmode = LED_SHOW_FLAGS;
    810810}
    811811
     
    820820    leds = kbd->ledflagstate;
    821821    if (kbd->ledmode == LED_SHOW_MEM) {
    822         if (ledptrs[0].valid) {
    823             if (*ledptrs[0].addr & ledptrs[0].mask)
    824               leds |= 1;
    825             else
    826               leds &= ~1;
    827         }
    828         if (ledptrs[1].valid) {
    829             if (*ledptrs[1].addr & ledptrs[1].mask)
    830               leds |= 2;
    831             else
    832               leds &= ~2;
    833         }
    834         if (ledptrs[2].valid) {
    835             if (*ledptrs[2].addr & ledptrs[2].mask)
    836               leds |= 4;
    837             else
    838               leds &= ~4;
    839         }
     822  if (ledptrs[0].valid) {
     823      if (*ledptrs[0].addr & ledptrs[0].mask)
     824        leds |= 1;
     825      else
     826        leds &= ~1;
     827  }
     828  if (ledptrs[1].valid) {
     829      if (*ledptrs[1].addr & ledptrs[1].mask)
     830        leds |= 2;
     831      else
     832        leds &= ~2;
     833  }
     834  if (ledptrs[2].valid) {
     835      if (*ledptrs[2].addr & ledptrs[2].mask)
     836        leds |= 4;
     837      else
     838        leds &= ~4;
     839  }
    840840    }
    841841   return leds;
     
    857857static void kbd_bh(void)
    858858{
    859         unsigned char leds = getleds();
    860         if (leds != ledstate) {
    861                 ledstate = leds;
    862                 kbd_leds(leds);
    863         }
     859  unsigned char leds = getleds();
     860  if (leds != ledstate) {
     861    ledstate = leds;
     862    kbd_leds(leds);
     863  }
    864864}
    865865
     
    872872{
    873873
    874         int i;
    875         struct kbd_struct kbd0;
    876         kbd0.ledflagstate = kbd0.default_ledflagstate = KBD_DEFLEDS;
     874  int i;
     875  struct kbd_struct kbd0;
     876  kbd0.ledflagstate = kbd0.default_ledflagstate = KBD_DEFLEDS;
    877877   kbd0.ledmode = LED_SHOW_MEM;
    878         kbd0.lockstate = KBD_DEFLOCK;
    879         kbd0.slockstate = 0;
    880         kbd0.modeflags = KBD_DEFMODE;
    881         kbd0.kbdmode = VC_XLATE;
    882 
    883         for (i = 0 ; i < MAX_NR_CONSOLES ; i++)
    884                 kbd_table[i] = kbd0;
    885 
    886         kbd_init_hw();
    887         mark_bh(KEYBOARD_BH);
    888         return 0;
    889 }
     878  kbd0.lockstate = KBD_DEFLOCK;
     879  kbd0.slockstate = 0;
     880  kbd0.modeflags = KBD_DEFMODE;
     881  kbd0.kbdmode = VC_XLATE;
     882
     883  for (i = 0 ; i < MAX_NR_CONSOLES ; i++)
     884    kbd_table[i] = kbd0;
     885
     886  kbd_init_hw();
     887  mark_bh(KEYBOARD_BH);
     888  return 0;
     889}
Note: See TracChangeset for help on using the changeset viewer.