Changeset c2417bc in mainline for kernel/genarch/src


Ignore:
Timestamp:
2009-04-21T12:46:26Z (16 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
f2d2c7ba
Parents:
44b7783
Message:

change the way how input devices are wired together according to ticket #44
(also the proposal ​http://lists.modry.cz/cgi-bin/private/helenos-devel/2009-March/002507.html)

Location:
kernel/genarch/src
Files:
6 edited
1 moved

Legend:

Unmodified
Added
Removed

  • kernel/genarch/src/drivers/dsrln/dsrlnin.c

    r44b7783 rc2417bc  
    4141#include <ddi/device.h>
    4242
    43 static indev_operations_t kbrdin_ops = {
    44         .poll = NULL
    45 };
    46 
    4743static irq_ownership_t dsrlnin_claim(irq_t *irq)
    4844{
    … …  
    5551        dsrlnin_t *dev = instance->dsrlnin;
    5652       
    57         indev_push_character(&instance->kbrdin, pio_read_8(&dev->data));
     53        indev_push_character(instance->srlnin, pio_read_8(&dev->data));
    5854}
    5955
    60 indev_t *dsrlnin_init(dsrlnin_t *dev, inr_t inr)
     56dsrlnin_instance_t *dsrlnin_init(dsrlnin_t *dev, inr_t inr)
    6157{
    6258        dsrlnin_instance_t *instance
    6359            = malloc(sizeof(dsrlnin_instance_t), FRAME_ATOMIC);
    64         if (!instance)
    65                 return NULL;
     60        if (instance) {
     61                instance->dsrlnin = dev;
     62                instance->srlnin = NULL;
     63               
     64                irq_initialize(&instance->irq);
     65                instance->irq.devno = device_assign_devno();
     66                instance->irq.inr = inr;
     67                instance->irq.claim = dsrlnin_claim;
     68                instance->irq.handler = dsrlnin_irq_handler;
     69                instance->irq.instance = instance;
     70        }
    6671       
    67         indev_initialize("dsrlnin", &instance->kbrdin, &kbrdin_ops);
     72        return instance;
     73}
     74
     75void dsrlnin_wire(dsrlnin_instance_t *instance, indev_t *srlnin)
     76{
     77        ASSERT(instance);
     78        ASSERT(srlnin);
    6879       
    69         instance->dsrlnin = dev;
    70        
    71         irq_initialize(&instance->irq);
    72         instance->irq.devno = device_assign_devno();
    73         instance->irq.inr = inr;
    74         instance->irq.claim = dsrlnin_claim;
    75         instance->irq.handler = dsrlnin_irq_handler;
    76         instance->irq.instance = instance;
     80        instance->srlnin = srlnin;
    7781        irq_register(&instance->irq);
    78        
    79         return &instance->kbrdin;
    8082}
    8183

  • kernel/genarch/src/drivers/i8042/i8042.c

    r44b7783 rc2417bc  
    4545#include <ddi/device.h>
    4646
    47 static indev_operations_t kbrdin_ops = {
    48         .poll = NULL
    49 };
    50 
    5147#define i8042_SET_COMMAND  0x60
    5248#define i8042_COMMAND      0x69
    … …  
    7571        if (((status = pio_read_8(&dev->status)) & i8042_BUFFER_FULL_MASK)) {
    7672                uint8_t data = pio_read_8(&dev->data);
    77                 indev_push_character(&instance->kbrdin, data);
     73                indev_push_character(instance->kbrdin, data);
    7874        }
    7975}
    8076
     77/**< Clear input buffer. */
     78static void i8042_clear_buffer(i8042_t *dev)
     79{
     80        while (pio_read_8(&dev->status) & i8042_BUFFER_FULL_MASK)
     81                (void) pio_read_8(&dev->data);
     82}
     83
    8184/** Initialize i8042. */
    82 indev_t *i8042_init(i8042_t *dev, inr_t inr)
     85i8042_instance_t *i8042_init(i8042_t *dev, inr_t inr)
    8386{
    8487        i8042_instance_t *instance
    8588            = malloc(sizeof(i8042_instance_t), FRAME_ATOMIC);
    86         if (!instance)
    87                 return NULL;
     89        if (instance) {
     90                instance->i8042 = dev;
     91                instance->kbrdin = NULL;
     92               
     93                irq_initialize(&instance->irq);
     94                instance->irq.devno = device_assign_devno();
     95                instance->irq.inr = inr;
     96                instance->irq.claim = i8042_claim;
     97                instance->irq.handler = i8042_irq_handler;
     98                instance->irq.instance = instance;
     99               
     100        }
    88101       
    89         indev_initialize("i8042", &instance->kbrdin, &kbrdin_ops);
     102        return instance;
     103}
     104
     105void i8042_wire(i8042_instance_t *instance, indev_t *kbrdin)
     106{
     107        ASSERT(instance);
     108        ASSERT(kbrdin);
    90109       
    91         instance->i8042 = dev;
    92        
    93         irq_initialize(&instance->irq);
    94         instance->irq.devno = device_assign_devno();
    95         instance->irq.inr = inr;
    96         instance->irq.claim = i8042_claim;
    97         instance->irq.handler = i8042_irq_handler;
    98         instance->irq.instance = instance;
     110        instance->kbrdin = kbrdin;
    99111        irq_register(&instance->irq);
    100        
    101         /* Clear input buffer */
    102         while (pio_read_8(&dev->status) & i8042_BUFFER_FULL_MASK)
    103                 (void) pio_read_8(&dev->data);
    104        
    105         return &instance->kbrdin;
     112        i8042_clear_buffer(instance->i8042);
    106113}
    107114
    … …  
    111118        interrupts_disable();
    112119       
    113         /* Clear input buffer */
    114         while (pio_read_8(&dev->status) & i8042_BUFFER_FULL_MASK)
    115                 (void) pio_read_8(&dev->data);
     120        i8042_clear_buffer(dev);
    116121       
    117122        /* Reset CPU */

  • kernel/genarch/src/drivers/ns16550/ns16550.c

    r44b7783 rc2417bc  
    4444#define LSR_DATA_READY  0x01
    4545
    46 static indev_operations_t kbrdin_ops = {
    47         .poll = NULL
    48 };
    49 
    5046static irq_ownership_t ns16550_claim(irq_t *irq)
    5147{
    … …  
    6561       
    6662        if (pio_read_8(&dev->lsr) & LSR_DATA_READY) {
    67                 uint8_t x = pio_read_8(&dev->rbr);
    68                 indev_push_character(&instance->kbrdin, x);
     63                uint8_t data = pio_read_8(&dev->rbr);
     64                indev_push_character(instance->kbrdin, data);
    6965        }
     66}
     67
     68/**< Clear input buffer. */
     69static void ns16550_clear_buffer(ns16550_t *dev)
     70{
     71        while ((pio_read_8(&dev->lsr) & LSR_DATA_READY))
     72                (void) pio_read_8(&dev->rbr);
    7073}
    7174
    … …  
    7881 * @param cir_arg  First argument to cir.
    7982 *
    80  * @return Keyboard device pointer or NULL on failure.
     83 * @return Keyboard instance or NULL on failure.
    8184 *
    8285 */
    83 indev_t *ns16550_init(ns16550_t *dev, inr_t inr, cir_t cir, void *cir_arg)
     86ns16550_instance_t *ns16550_init(ns16550_t *dev, inr_t inr, cir_t cir, void *cir_arg)
    8487{
    8588        ns16550_instance_t *instance
    8689            = malloc(sizeof(ns16550_instance_t), FRAME_ATOMIC);
    87         if (!instance)
    88                 return NULL;
     90        if (instance) {
     91                instance->ns16550 = dev;
     92                instance->kbrdin = NULL;
     93               
     94                irq_initialize(&instance->irq);
     95                instance->irq.devno = device_assign_devno();
     96                instance->irq.inr = inr;
     97                instance->irq.claim = ns16550_claim;
     98                instance->irq.handler = ns16550_irq_handler;
     99                instance->irq.instance = instance;
     100                instance->irq.cir = cir;
     101                instance->irq.cir_arg = cir_arg;
     102        }
    89103       
    90         indev_initialize("ns16550", &instance->kbrdin, &kbrdin_ops);
     104        return instance;
     105}
     106
     107void ns16550_wire(ns16550_instance_t *instance, indev_t *kbrdin)
     108{
     109        ASSERT(instance);
     110        ASSERT(kbrdin);
    91111       
    92         instance->ns16550 = dev;
    93        
    94         irq_initialize(&instance->irq);
    95         instance->irq.devno = device_assign_devno();
    96         instance->irq.inr = inr;
    97         instance->irq.claim = ns16550_claim;
    98         instance->irq.handler = ns16550_irq_handler;
    99         instance->irq.instance = instance;
    100         instance->irq.cir = cir;
    101         instance->irq.cir_arg = cir_arg;
     112        instance->kbrdin = kbrdin;
    102113        irq_register(&instance->irq);
    103114       
    104         while ((pio_read_8(&dev->lsr) & LSR_DATA_READY))
    105                 (void) pio_read_8(&dev->rbr);
     115        ns16550_clear_buffer(instance->ns16550);
    106116       
    107117        /* Enable interrupts */
    108         pio_write_8(&dev->ier, IER_ERBFI);
    109         pio_write_8(&dev->mcr, MCR_OUT2);
    110        
    111         return &instance->kbrdin;
     118        pio_write_8(&instance->ns16550->ier, IER_ERBFI);
     119        pio_write_8(&instance->ns16550->mcr, MCR_OUT2);
    112120}
    113121

  • kernel/genarch/src/drivers/via-cuda/cuda.c

    r44b7783 rc2417bc  
    11/*
    2  * Copyright (c) 2007 Michal Kebrt
     2 * Copyright (c) 2006 Martin Decky
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup arm32
     29/** @addtogroup genarch
    3030 * @{
    3131 */
    3232/** @file
    33  *  @brief Console.
    3433 */
    3534
    36 #include <console/console.h>
    37 #include <arch/console.h>
    38 #include <genarch/fb/fb.h>
     35#include <genarch/drivers/via-cuda/cuda.h>
     36#include <console/chardev.h>
     37#include <ddi/irq.h>
     38#include <arch/asm.h>
     39#include <mm/slab.h>
     40#include <ddi/device.h>
    3941
    40 /** Acquire console back for kernel. */
    41 void arch_grab_console(void)
     42static irq_ownership_t cuda_claim(irq_t *irq)
    4243{
    43 #ifdef CONFIG_FB
    44         fb_redraw();
    45 #endif
     44        return IRQ_DECLINE;
    4645}
    4746
    48 /** Return console to userspace. */
    49 void arch_release_console(void)
     47static void cuda_irq_handler(irq_t *irq)
    5048{
    5149}
    5250
     51cuda_instance_t *cuda_init(cuda_t *dev, inr_t inr, cir_t cir, void *cir_arg)
     52{
     53        cuda_instance_t *instance
     54            = malloc(sizeof(cuda_instance_t), FRAME_ATOMIC);
     55        if (instance) {
     56                instance->cuda = dev;
     57                instance->kbrdin = NULL;
     58               
     59                irq_initialize(&instance->irq);
     60                instance->irq.devno = device_assign_devno();
     61                instance->irq.inr = inr;
     62                instance->irq.claim = cuda_claim;
     63                instance->irq.handler = cuda_irq_handler;
     64                instance->irq.instance = instance;
     65                instance->irq.cir = cir;
     66                instance->irq.cir_arg = cir_arg;
     67        }
     68       
     69        return instance;
     70}
     71
     72void cuda_wire(cuda_instance_t *instance, indev_t *kbrdin)
     73{
     74}
     75
     76
    5377/** @}
    5478 */

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

    r44b7783 rc2417bc  
    4242#include <ddi/device.h>
    4343
    44 static indev_operations_t kbrdin_ops = {
    45         .poll = NULL
    46 };
    47 
    4844static inline void z8530_write(ioport8_t *ctl, uint8_t reg, uint8_t val)
    4945{
    … …  
    8379       
    8480        if (z8530_read(&dev->ctl_a, RR0) & RR0_RCA) {
    85                 uint8_t x = z8530_read(&dev->ctl_a, RR8);
    86                 indev_push_character(&instance->kbrdin, x);
     81                uint8_t data = z8530_read(&dev->ctl_a, RR8);
     82                indev_push_character(instance->kbrdin, data);
    8783        }
    8884}
    8985
    9086/** Initialize z8530. */
    91 indev_t *z8530_init(z8530_t *dev, inr_t inr, cir_t cir, void *cir_arg)
     87z8530_instance_t *z8530_init(z8530_t *dev, inr_t inr, cir_t cir, void *cir_arg)
    9288{
    9389        z8530_instance_t *instance
    9490            = malloc(sizeof(z8530_instance_t), FRAME_ATOMIC);
    95         if (!instance)
    96                 return false;
     91        if (instance) {
     92                instance->z8530 = dev;
     93                instance->kbrdin = NULL;
     94               
     95                irq_initialize(&instance->irq);
     96                instance->irq.devno = device_assign_devno();
     97                instance->irq.inr = inr;
     98                instance->irq.claim = z8530_claim;
     99                instance->irq.handler = z8530_irq_handler;
     100                instance->irq.instance = instance;
     101                instance->irq.cir = cir;
     102                instance->irq.cir_arg = cir_arg;
     103        }
    97104       
    98         indev_initialize("z8530", &instance->kbrdin, &kbrdin_ops);
     105        return instance;
     106}
     107
     108void z8530_wire(z8530_instance_t *instance, indev_t *kbrdin)
     109{
     110        ASSERT(instance);
     111        ASSERT(kbrdin);
    99112       
    100         instance->z8530 = dev;
     113        instance->kbrdin = kbrdin;
    101114       
    102         irq_initialize(&instance->irq);
    103         instance->irq.devno = device_assign_devno();
    104         instance->irq.inr = inr;
    105         instance->irq.claim = z8530_claim;
    106         instance->irq.handler = z8530_irq_handler;
    107         instance->irq.instance = instance;
    108         instance->irq.cir = cir;
    109         instance->irq.cir_arg = cir_arg;
    110115        irq_register(&instance->irq);
    111116       
    112         (void) z8530_read(&dev->ctl_a, RR8);
     117        (void) z8530_read(&instance->z8530->ctl_a, RR8);
    113118       
    114119        /*
    … …  
    116121         * to set FHC UART interrupt state to idle.
    117122         */
    118         z8530_write(&dev->ctl_a, WR0, WR0_TX_IP_RST);
     123        z8530_write(&instance->z8530->ctl_a, WR0, WR0_TX_IP_RST);
    119124       
    120125        /* interrupt on all characters */
    121         z8530_write(&dev->ctl_a, WR1, WR1_IARCSC);
     126        z8530_write(&instance->z8530->ctl_a, WR1, WR1_IARCSC);
    122127       
    123128        /* 8 bits per character and enable receiver */
    124         z8530_write(&dev->ctl_a, WR3, WR3_RX8BITSCH | WR3_RX_ENABLE);
     129        z8530_write(&instance->z8530->ctl_a, WR3, WR3_RX8BITSCH | WR3_RX_ENABLE);
    125130       
    126131        /* Master Interrupt Enable. */
    127         z8530_write(&dev->ctl_a, WR9, WR9_MIE);
    128        
    129         return &instance->kbrdin;
     132        z8530_write(&instance->z8530->ctl_a, WR9, WR9_MIE);
    130133}
    131134

  • kernel/genarch/src/kbrd/kbrd.c

    r44b7783 rc2417bc  
    6060#define LOCKED_CAPSLOCK   (1 << 0)
    6161
    62 static indev_t kbrdout;
    63 
    64 indev_operations_t kbrdout_ops = {
     62static indev_operations_t kbrd_raw_ops = {
    6563        .poll = NULL
    6664};
    67 
    68 SPINLOCK_INITIALIZE(keylock);   /**< keylock protects keyflags and lockflags. */
    69 static volatile int keyflags;   /**< Tracking of multiple keypresses. */
    70 static volatile int lockflags;  /**< Tracking of multiple keys lockings. */
    7165
    7266/** Process release of key.
    … …  
    7468 * @param sc Scancode of the key being released.
    7569 */
    76 static void key_released(wchar_t sc)
     70static void key_released(kbrd_instance_t *instance, wchar_t sc)
    7771{
    78         spinlock_lock(&keylock);
     72        spinlock_lock(&instance->keylock);
     73       
    7974        switch (sc) {
    8075        case SC_LSHIFT:
    8176        case SC_RSHIFT:
    82                 keyflags &= ~PRESSED_SHIFT;
     77                instance->keyflags &= ~PRESSED_SHIFT;
    8378                break;
    8479        case SC_CAPSLOCK:
    85                 keyflags &= ~PRESSED_CAPSLOCK;
    86                 if (lockflags & LOCKED_CAPSLOCK)
    87                         lockflags &= ~LOCKED_CAPSLOCK;
     80                instance->keyflags &= ~PRESSED_CAPSLOCK;
     81                if (instance->lockflags & LOCKED_CAPSLOCK)
     82                        instance->lockflags &= ~LOCKED_CAPSLOCK;
    8883                else
    89                         lockflags |= LOCKED_CAPSLOCK;
     84                        instance->lockflags |= LOCKED_CAPSLOCK;
    9085                break;
    9186        default:
    9287                break;
    9388        }
    94         spinlock_unlock(&keylock);
     89       
     90        spinlock_unlock(&instance->keylock);
    9591}
    9692
    … …  
    9995 * @param sc Scancode of the key being pressed.
    10096 */
    101 static void key_pressed(wchar_t sc)
     97static void key_pressed(kbrd_instance_t *instance, wchar_t sc)
    10298{
    10399        bool letter;
    … …  
    105101        bool capslock;
    106102       
    107         spinlock_lock(&keylock);
     103        spinlock_lock(&instance->keylock);
     104       
    108105        switch (sc) {
    109106        case SC_LSHIFT:
    110107        case SC_RSHIFT:
    111                 keyflags |= PRESSED_SHIFT;
     108                instance->keyflags |= PRESSED_SHIFT;
    112109                break;
    113110        case SC_CAPSLOCK:
    114                 keyflags |= PRESSED_CAPSLOCK;
     111                instance->keyflags |= PRESSED_CAPSLOCK;
    115112                break;
    116113        case SC_SCAN_ESCAPE:
    … …  
    118115        default:
    119116                letter = islower(sc_primary_map[sc]);
    120                 shift = keyflags & PRESSED_SHIFT;
    121                 capslock = (keyflags & PRESSED_CAPSLOCK) ||
    122                     (lockflags & LOCKED_CAPSLOCK);
     117                shift = instance->keyflags & PRESSED_SHIFT;
     118                capslock = (instance->keyflags & PRESSED_CAPSLOCK) ||
     119                    (instance->lockflags & LOCKED_CAPSLOCK);
    123120               
    124121                if ((letter) && (capslock))
    … …  
    126123               
    127124                if (shift)
    128                         indev_push_character(stdin, sc_secondary_map[sc]);
     125                        indev_push_character(instance->sink, sc_secondary_map[sc]);
    129126                else
    130                         indev_push_character(stdin, sc_primary_map[sc]);
     127                        indev_push_character(instance->sink, sc_primary_map[sc]);
    131128                break;
    132129        }
    133         spinlock_unlock(&keylock);
     130       
     131        spinlock_unlock(&instance->keylock);
    134132}
    135133
    136134static void kkbrd(void *arg)
    137135{
    138         indev_t *in = (indev_t *) arg;
     136        kbrd_instance_t *instance = (kbrd_instance_t *) arg;
    139137       
    140138        while (true) {
    141                 wchar_t sc = _getc(in);
     139                wchar_t sc = indev_pop_character(&instance->raw);
    142140               
    143141                if (sc == IGNORE_CODE)
    … …  
    145143               
    146144                if (sc & KEY_RELEASE)
    147                         key_released((sc ^ KEY_RELEASE) & 0x7f);
     145                        key_released(instance, (sc ^ KEY_RELEASE) & 0x7f);
    148146                else
    149                         key_pressed(sc & 0x7f);
     147                        key_pressed(instance, sc & 0x7f);
    150148        }
    151149}
    152150
    153 void kbrd_init(indev_t *devin)
     151kbrd_instance_t *kbrd_init(void)
    154152{
    155         indev_initialize("kbrd", &kbrdout, &kbrdout_ops);
    156         thread_t *thread
    157             = thread_create(kkbrd, devin, TASK, 0, "kkbrd", false);
     153        kbrd_instance_t *instance
     154            = malloc(sizeof(kbrd_instance_t), FRAME_ATOMIC);
     155        if (instance) {
     156                instance->thread
     157                        = thread_create(kkbrd, (void *) instance, TASK, 0, "kkbrd", false);
     158               
     159                if (!instance->thread) {
     160                        free(instance);
     161                        return NULL;
     162                }
     163               
     164                instance->sink = NULL;
     165                indev_initialize("kbrd", &instance->raw, &kbrd_raw_ops);
     166               
     167                spinlock_initialize(&instance->keylock, "instance_keylock");
     168                instance->keyflags = 0;
     169                instance->lockflags = 0;
     170        }
    158171       
    159         if (thread) {
    160                 stdin = &kbrdout;
    161                 thread_ready(thread);
    162         }
     172        return instance;
     173}
     174
     175indev_t *kbrd_wire(kbrd_instance_t *instance, indev_t *sink)
     176{
     177        ASSERT(instance);
     178        ASSERT(sink);
     179       
     180        instance->sink = sink;
     181        thread_ready(instance->thread);
     182       
     183        return &instance->raw;
    163184}
    164185

  • kernel/genarch/src/srln/srln.c

    r44b7783 rc2417bc  
    4242#include <string.h>
    4343
    44 static indev_t srlnout;
    45 
    46 indev_operations_t srlnout_ops = {
     44static indev_operations_t srln_raw_ops = {
    4745        .poll = NULL
    4846};
    … …  
    5048static void ksrln(void *arg)
    5149{
    52         indev_t *in = (indev_t *) arg;
     50        srln_instance_t *instance = (srln_instance_t *) arg;
    5351        bool cr = false;
    5452        uint32_t escape = 0;
    5553       
    5654        while (true) {
    57                 wchar_t ch = _getc(in);
     55                wchar_t ch = indev_pop_character(&instance->raw);
    5856               
    5957                /* ANSI escape sequence processing */
    … …  
    123121                        ch = '\b';
    124122               
    125                 indev_push_character(stdin, ch);
     123                indev_push_character(instance->sink, ch);
    126124        }
    127125}
    128126
    129 void srln_init(indev_t *devin)
     127srln_instance_t *srln_init(void)
    130128{
    131         indev_initialize("srln", &srlnout, &srlnout_ops);
    132         thread_t *thread
    133             = thread_create(ksrln, devin, TASK, 0, "ksrln", false);
     129        srln_instance_t *instance
     130            = malloc(sizeof(srln_instance_t), FRAME_ATOMIC);
     131        if (instance) {
     132                instance->thread
     133                        = thread_create(ksrln, (void *) instance, TASK, 0, "ksrln", false);
     134               
     135                if (!instance->thread) {
     136                        free(instance);
     137                        return NULL;
     138                }
     139               
     140                instance->sink = NULL;
     141                indev_initialize("srln", &instance->raw, &srln_raw_ops);
     142        }
    134143       
    135         if (thread) {
    136                 stdin = &srlnout;
    137                 thread_ready(thread);
    138         }
     144        return instance;
     145}
     146
     147indev_t *srln_wire(srln_instance_t *instance, indev_t *sink)
     148{
     149        ASSERT(instance);
     150        ASSERT(sink);
     151       
     152        instance->sink = sink;
     153        thread_ready(instance->thread);
     154       
     155        return &instance->raw;
    139156}
    140157
Note: See TracChangeset for help on using the changeset viewer.