Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset b6f2ebc in mainline


Ignore:
Timestamp:
2009-03-12T17:52:33Z (13 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master
Children:
a0e1b48
Parents:
a7efdec
Message:

wire keyboard/serial module and device drivers in a more obvious way
(first a device driver is initialized and then it is connected to the generic module)

Location:
kernel/genarch
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • kernel/genarch/include/kbrd/kbrd.h

    ra7efdec rb6f2ebc  
    2727 */
    2828
    29 /** @addtogroup genarch 
     29/** @addtogroup genarch
    3030 * @{
    3131 */
     
    3939#include <console/chardev.h>
    4040
    41 extern chardev_t kbrdin;
    42 
    43 extern void kbrd_init(chardev_t *);
     41extern void kbrd_init(indev_t *devin);
    4442
    4543#endif
  • kernel/genarch/include/srln/srln.h

    ra7efdec rb6f2ebc  
    2727 */
    2828
    29 /** @addtogroup genarch 
     29/** @addtogroup genarch
    3030 * @{
    3131 */
     
    3939#include <console/chardev.h>
    4040
    41 extern chardev_t srlnin;
    42 
    43 extern void srln_init(chardev_t *);
     41extern void srln_init(indev_t *devin);
    4442
    4543#endif
  • kernel/genarch/src/kbrd/kbrd.c

    ra7efdec rb6f2ebc  
    2727 */
    2828
    29 /** @addtogroup genarch 
     29/** @addtogroup genarch
    3030 * @{
    3131 */
    3232/**
    3333 * @file
    34  * @brief       Keyboard processing.
     34 * @brief Keyboard processing.
    3535 */
    3636
     
    5454
    5555#ifdef CONFIG_SUN_KBD
    56 #       define IGNORE_CODE      0x7f
    57 #endif
    58 
    59 #define KEY_RELEASE             0x80
    60 
    61 #define PRESSED_SHIFT           (1 << 0)
    62 #define PRESSED_CAPSLOCK        (1 << 1)
    63 #define LOCKED_CAPSLOCK         (1 << 0)
    64 
    65 chardev_t kbrdin;
    66 static chardev_t *kbdout;
    67 
    68 static void kbrdin_suspend(chardev_t *d)
    69 {
    70 }
    71 
    72 static void kbrdin_resume(chardev_t *d)
    73 {
    74 }
    75 
    76 chardev_operations_t kbrdin_ops = {
    77         .suspend = kbrdin_suspend,
    78         .resume = kbrdin_resume,
     56        #define IGNORE_CODE  0x7f
     57#endif
     58
     59#define KEY_RELEASE  0x80
     60
     61#define PRESSED_SHIFT     (1 << 0)
     62#define PRESSED_CAPSLOCK  (1 << 1)
     63#define LOCKED_CAPSLOCK   (1 << 0)
     64
     65static indev_t kbrdout;
     66
     67indev_operations_t kbrdout_ops = {
     68        .poll = NULL
    7969};
    8070
    81 SPINLOCK_INITIALIZE(keylock);           /**< keylock protects keyflags and lockflags. */
    82 static volatile int keyflags;           /**< Tracking of multiple keypresses. */
    83 static volatile int lockflags;          /**< Tracking of multiple keys lockings. */
     71SPINLOCK_INITIALIZE(keylock);   /**< keylock protects keyflags and lockflags. */
     72static volatile int keyflags;   /**< Tracking of multiple keypresses. */
     73static volatile int lockflags;  /**< Tracking of multiple keys lockings. */
    8474
    8575static void key_released(uint8_t);
     
    8878static void kkbrd(void *arg)
    8979{
    90         chardev_t *in = (chardev_t *) arg;
    91         uint8_t sc;
    92 
    93         while (1) {
    94                 sc = _getc(in);
    95 
     80        indev_t *in = (indev_t *) arg;
     81       
     82        while (true) {
     83                uint8_t sc = _getc(in);
     84               
    9685#ifdef CONFIG_SUN_KBD
    9786                if (sc == IGNORE_CODE)
     
    10695}
    10796
    108 
    109 void kbrd_init(chardev_t *devout)
    110 {
    111         thread_t *t;
    112 
    113         chardev_initialize("kbrd", &kbrdin, &kbrdin_ops);
    114         kbdout = devout;
     97void kbrd_init(indev_t *devin)
     98{
     99        indev_initialize("kbrd", &kbrdout, &kbrdout_ops);
     100        thread_t *thread
     101            = thread_create(kkbrd, devin, TASK, 0, "kkbrd", false);
    115102       
    116         t = thread_create(kkbrd, &kbrdin, TASK, 0, "kkbrd", false);
    117         ASSERT(t);
    118         thread_ready(t);
     103        if (thread) {
     104                stdin = &kbrdout;
     105                thread_ready(thread);
     106        }
    119107}
    120108
     
    154142        bool shift, capslock;
    155143        bool letter = false;
    156 
     144       
    157145        spinlock_lock(&keylock);
    158146        switch (sc) {
    159147        case SC_LSHIFT:
    160148        case SC_RSHIFT:
    161                 keyflags |= PRESSED_SHIFT;
     149                keyflags |= PRESSED_SHIFT;
    162150                break;
    163151        case SC_CAPSLOCK:
     
    167155                break;
    168156        case SC_LEFTARR:
    169                 chardev_push_character(kbdout, 0x1b);
    170                 chardev_push_character(kbdout, 0x5b);
    171                 chardev_push_character(kbdout, 0x44);
     157                indev_push_character(stdin, 0x1b);
     158                indev_push_character(stdin, 0x5b);
     159                indev_push_character(stdin, 0x44);
    172160                break;
    173161        case SC_RIGHTARR:
    174                 chardev_push_character(kbdout, 0x1b);
    175                 chardev_push_character(kbdout, 0x5b);
    176                 chardev_push_character(kbdout, 0x43);
     162                indev_push_character(stdin, 0x1b);
     163                indev_push_character(stdin, 0x5b);
     164                indev_push_character(stdin, 0x43);
    177165                break;
    178166        case SC_UPARR:
    179                 chardev_push_character(kbdout, 0x1b);
    180                 chardev_push_character(kbdout, 0x5b);
    181                 chardev_push_character(kbdout, 0x41);
     167                indev_push_character(stdin, 0x1b);
     168                indev_push_character(stdin, 0x5b);
     169                indev_push_character(stdin, 0x41);
    182170                break;
    183171        case SC_DOWNARR:
    184                 chardev_push_character(kbdout, 0x1b);
    185                 chardev_push_character(kbdout, 0x5b);
    186                 chardev_push_character(kbdout, 0x42);
     172                indev_push_character(stdin, 0x1b);
     173                indev_push_character(stdin, 0x5b);
     174                indev_push_character(stdin, 0x42);
    187175                break;
    188176        case SC_HOME:
    189                 chardev_push_character(kbdout, 0x1b);
    190                 chardev_push_character(kbdout, 0x4f);
    191                 chardev_push_character(kbdout, 0x48);
     177                indev_push_character(stdin, 0x1b);
     178                indev_push_character(stdin, 0x4f);
     179                indev_push_character(stdin, 0x48);
    192180                break;
    193181        case SC_END:
    194                 chardev_push_character(kbdout, 0x1b);
    195                 chardev_push_character(kbdout, 0x4f);
    196                 chardev_push_character(kbdout, 0x46);
     182                indev_push_character(stdin, 0x1b);
     183                indev_push_character(stdin, 0x4f);
     184                indev_push_character(stdin, 0x46);
    197185                break;
    198186        case SC_DELETE:
    199                 chardev_push_character(kbdout, 0x1b);
    200                 chardev_push_character(kbdout, 0x5b);
    201                 chardev_push_character(kbdout, 0x33);
    202                 chardev_push_character(kbdout, 0x7e);
     187                indev_push_character(stdin, 0x1b);
     188                indev_push_character(stdin, 0x5b);
     189                indev_push_character(stdin, 0x33);
     190                indev_push_character(stdin, 0x7e);
    203191                break;
    204192        default:
    205                 letter = islower(ascii);
     193                letter = islower(ascii);
    206194                capslock = (keyflags & PRESSED_CAPSLOCK) ||
    207195                    (lockflags & LOCKED_CAPSLOCK);
     
    211199                if (shift)
    212200                        map = sc_secondary_map;
    213                 chardev_push_character(kbdout, map[sc]);
     201                indev_push_character(stdin, map[sc]);
    214202                break;
    215203        }
  • kernel/genarch/src/srln/srln.c

    ra7efdec rb6f2ebc  
    2727 */
    2828
    29 /** @addtogroup genarch 
     29/** @addtogroup genarch
    3030 * @{
    3131 */
    3232/**
    3333 * @file
    34  * @brief       Serial line processing.
     34 * @brief Serial line processing.
    3535 */
    3636
     
    4141#include <arch.h>
    4242
    43 chardev_t srlnin;
    44 static chardev_t *srlnout;
     43static indev_t srlnout;
    4544
    46 static void srlnin_suspend(chardev_t *d)
    47 {
    48 }
    49 
    50 static void srlnin_resume(chardev_t *d)
    51 {
    52 }
    53 
    54 chardev_operations_t srlnin_ops = {
    55         .suspend = srlnin_suspend,
    56         .resume = srlnin_resume,
     45indev_operations_t srlnout_ops = {
     46        .poll = NULL
    5747};
    5848
    5949static void ksrln(void *arg)
    6050{
    61         chardev_t *in = (chardev_t *) arg;
    62         uint8_t ch;
    63 
    64         while (1) {
    65                 ch = _getc(in);
     51        indev_t *in = (indev_t *) arg;
     52        bool cr = false;
     53       
     54        while (true) {
     55                uint8_t ch = _getc(in);
    6656               
    67                 if (ch == '\r')
     57                if ((ch == '\n') && (cr)) {
     58                        cr = false;
    6859                        continue;
     60                }
    6961               
    70                 chardev_push_character(srlnout, ch);
     62                if (ch == '\r') {
     63                        ch = '\n';
     64                        cr = true;
     65                } else
     66                        cr = false;
     67               
     68                if (ch == 0x7f)
     69                        ch = '\b';
     70               
     71                indev_push_character(stdin, ch);
    7172        }
    7273}
    7374
    74 
    75 void srln_init(chardev_t *devout)
     75void srln_init(indev_t *devin)
    7676{
    77         thread_t *t;
    78 
    79         chardev_initialize("srln", &srlnin, &srlnin_ops);
    80         srlnout = devout;
     77        indev_initialize("srln", &srlnout, &srlnout_ops);
     78        thread_t *thread
     79            = thread_create(ksrln, devin, TASK, 0, "ksrln", false);
    8180       
    82         t = thread_create(ksrln, &srlnin, TASK, 0, "ksrln", false);
    83         ASSERT(t);
    84         thread_ready(t);
     81        if (thread) {
     82                stdin = &srlnout;
     83                thread_ready(thread);
     84        }
    8585}
    8686
    8787/** @}
    8888 */
    89 
Note: See TracChangeset for help on using the changeset viewer.