Changeset d46c6ecd in mainline for kernel/genarch/src/kbd/z8530.c


Ignore:
Timestamp:
2006-08-09T16:09:05Z (20 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
8b4be29
Parents:
287920f
Message:

Move code duplicated in i8042.c and z8530.c to key.c.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • kernel/genarch/src/kbd/z8530.c

    r287920f rd46c6ecd  
    4343
    4444#include <genarch/kbd/z8530.h>
     45#include <genarch/kbd/key.h>
    4546#include <genarch/kbd/scanc.h>
    4647#include <genarch/kbd/scanc_sun.h>
    … …  
    5051#include <arch/asm.h>
    5152#include <arch.h>
    52 #include <synch/spinlock.h>
    5353#include <typedefs.h>
    5454#include <console/chardev.h>
    5555#include <console/console.h>
    56 #include <macros.h>
    5756#include <interrupt.h>
    5857
    … …  
    8483#define z8530_MOUSE_DATA        0x20
    8584
    86 #define KEY_RELEASE     0x80
    87 
    8885/*
    8986 * These codes read from z8530 data register are silently ignored.
    … …  
    9188#define IGNORE_CODE     0x7f            /* all keys up */
    9289
    93 static void key_released(uint8_t sc);
    94 static void key_pressed(uint8_t sc);
    95 static char key_read(chardev_t *d);
    96 
    97 #define PRESSED_SHIFT           (1<<0)
    98 #define PRESSED_CAPSLOCK        (1<<1)
    99 #define LOCKED_CAPSLOCK         (1<<0)
    100 
    101 #define ACTIVE_READ_BUFF_SIZE 16        /* Must be power of 2 */
    102 
    103 static uint8_t active_read_buff[ACTIVE_READ_BUFF_SIZE];
    104 
    105 SPINLOCK_INITIALIZE(keylock);           /**< keylock protects keyflags and lockflags. */
    106 static volatile int keyflags;           /**< Tracking of multiple keypresses. */
    107 static volatile int lockflags;          /**< Tracking of multiple keys lockings. */
    108 
    10990static void z8530_suspend(chardev_t *);
    11091static void z8530_resume(chardev_t *);
    11192
    112 static chardev_t kbrd;
     93chardev_t kbrd;
    11394static chardev_operations_t ops = {
    11495        .suspend = z8530_suspend,
    … …  
    193174}
    194175
    195 /** Process release of key.
    196  *
    197  * @param sc Scancode of the key being released.
    198  */
    199 void key_released(uint8_t sc)
    200 {
    201         spinlock_lock(&keylock);
    202         switch (sc) {
    203             case SC_LSHIFT:
    204             case SC_RSHIFT:
    205                 keyflags &= ~PRESSED_SHIFT;
    206                 break;
    207             case SC_CAPSLOCK:
    208                 keyflags &= ~PRESSED_CAPSLOCK;
    209                 if (lockflags & LOCKED_CAPSLOCK)
    210                         lockflags &= ~LOCKED_CAPSLOCK;
    211                 else
    212                         lockflags |= LOCKED_CAPSLOCK;
    213                 break;
    214             default:
    215                 break;
    216         }
    217         spinlock_unlock(&keylock);
    218 }
    219 
    220 /** Process keypress.
    221  *
    222  * @param sc Scancode of the key being pressed.
    223  */
    224 void key_pressed(uint8_t sc)
    225 {
    226         char *map = sc_primary_map;
    227         char ascii = sc_primary_map[sc];
    228         bool shift, capslock;
    229         bool letter = false;
    230 
    231         spinlock_lock(&keylock);
    232         switch (sc) {
    233         case SC_LSHIFT:
    234         case SC_RSHIFT:
    235                 keyflags |= PRESSED_SHIFT;
    236                 break;
    237         case SC_CAPSLOCK:
    238                 keyflags |= PRESSED_CAPSLOCK;
    239                 break;
    240         case SC_SPEC_ESCAPE:
    241                 break;
    242         case SC_LEFTARR:
    243                 chardev_push_character(&kbrd, 0x1b);
    244                 chardev_push_character(&kbrd, 0x5b);
    245                 chardev_push_character(&kbrd, 0x44);
    246                 break;
    247         case SC_RIGHTARR:
    248                 chardev_push_character(&kbrd, 0x1b);
    249                 chardev_push_character(&kbrd, 0x5b);
    250                 chardev_push_character(&kbrd, 0x43);
    251                 break;
    252         case SC_UPARR:
    253                 chardev_push_character(&kbrd, 0x1b);
    254                 chardev_push_character(&kbrd, 0x5b);
    255                 chardev_push_character(&kbrd, 0x41);
    256                 break;
    257         case SC_DOWNARR:
    258                 chardev_push_character(&kbrd, 0x1b);
    259                 chardev_push_character(&kbrd, 0x5b);
    260                 chardev_push_character(&kbrd, 0x42);
    261                 break;
    262         case SC_HOME:
    263                 chardev_push_character(&kbrd, 0x1b);
    264                 chardev_push_character(&kbrd, 0x4f);
    265                 chardev_push_character(&kbrd, 0x48);
    266                 break;
    267         case SC_END:
    268                 chardev_push_character(&kbrd, 0x1b);
    269                 chardev_push_character(&kbrd, 0x4f);
    270                 chardev_push_character(&kbrd, 0x46);
    271                 break;
    272         case SC_DELETE:
    273                 chardev_push_character(&kbrd, 0x1b);
    274                 chardev_push_character(&kbrd, 0x5b);
    275                 chardev_push_character(&kbrd, 0x33);
    276                 chardev_push_character(&kbrd, 0x7e);
    277                 break;
    278         default:
    279                 letter = is_lower(ascii);
    280                 capslock = (keyflags & PRESSED_CAPSLOCK) || (lockflags & LOCKED_CAPSLOCK);
    281                 shift = keyflags & PRESSED_SHIFT;
    282                 if (letter && capslock)
    283                         shift = !shift;
    284                 if (shift)
    285                         map = sc_secondary_map;
    286                 chardev_push_character(&kbrd, map[sc]);
    287                 break;
    288         }
    289         spinlock_unlock(&keylock);
    290 }
    291 
    292176/* Called from getc(). */
    293177void z8530_resume(chardev_t *d)
    … …  
    300184}
    301185
    302 static uint8_t active_read_buff_read(void)
    303 {
    304         static int i=0;
    305         i &= (ACTIVE_READ_BUFF_SIZE-1);
    306         if(!active_read_buff[i]) {
    307                 return 0;
    308         }
    309         return active_read_buff[i++];
    310 }
    311 
    312 static void active_read_buff_write(uint8_t ch)
    313 {
    314         static int i=0;
    315         active_read_buff[i] = ch;
    316         i++;
    317         i &= (ACTIVE_READ_BUFF_SIZE-1);
    318         active_read_buff[i]=0;
    319 }
    320 
    321 
    322 static void active_read_key_pressed(uint8_t sc)
    323 {
    324         char *map = sc_primary_map;
    325         char ascii = sc_primary_map[sc];
    326         bool shift, capslock;
    327         bool letter = false;
    328 
    329         /*spinlock_lock(&keylock);*/
    330         switch (sc) {
    331         case SC_LSHIFT:
    332         case SC_RSHIFT:
    333                 keyflags |= PRESSED_SHIFT;
    334                 break;
    335         case SC_CAPSLOCK:
    336                 keyflags |= PRESSED_CAPSLOCK;
    337                 break;
    338         case SC_SPEC_ESCAPE:
    339                 break;
    340         case SC_LEFTARR:
    341                 active_read_buff_write(0x1b);
    342                 active_read_buff_write(0x5b);
    343                 active_read_buff_write(0x44);
    344                 break;
    345         case SC_RIGHTARR:
    346                 active_read_buff_write(0x1b);
    347                 active_read_buff_write(0x5b);
    348                 active_read_buff_write(0x43);
    349                 break;
    350         case SC_UPARR:
    351                 active_read_buff_write(0x1b);
    352                 active_read_buff_write(0x5b);
    353                 active_read_buff_write(0x41);
    354                 break;
    355         case SC_DOWNARR:
    356                 active_read_buff_write(0x1b);
    357                 active_read_buff_write(0x5b);
    358                 active_read_buff_write(0x42);
    359                 break;
    360         case SC_HOME:
    361                 active_read_buff_write(0x1b);
    362                 active_read_buff_write(0x4f);
    363                 active_read_buff_write(0x48);
    364                 break;
    365         case SC_END:
    366                 active_read_buff_write(0x1b);
    367                 active_read_buff_write(0x4f);
    368                 active_read_buff_write(0x46);
    369                 break;
    370         case SC_DELETE:
    371                 active_read_buff_write(0x1b);
    372                 active_read_buff_write(0x5b);
    373                 active_read_buff_write(0x33);
    374                 active_read_buff_write(0x7e);
    375                 break;
    376         default:
    377                 letter = is_lower(ascii);
    378                 capslock = (keyflags & PRESSED_CAPSLOCK) || (lockflags & LOCKED_CAPSLOCK);
    379                 shift = keyflags & PRESSED_SHIFT;
    380                 if (letter && capslock)
    381                         shift = !shift;
    382                 if (shift)
    383                         map = sc_secondary_map;
    384                 active_read_buff_write(map[sc]);
    385                 break;
    386         }
    387         /*spinlock_unlock(&keylock);*/
    388 
    389 }
    390 
    391 static char key_read(chardev_t *d)
     186char key_read(chardev_t *d)
    392187{
    393188        char ch;       
Note: See TracChangeset for help on using the changeset viewer.