Changeset c2417bc in mainline for kernel/genarch/src/drivers


Ignore:
Timestamp:
2009-04-21T12:46:26Z (17 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/drivers
Files:
4 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
Note: See TracChangeset for help on using the changeset viewer.