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

Changeset c2417bc in mainline


Ignore:
Timestamp:
2009-04-21T12:46:26Z (13 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master
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)

Files:
4 deleted
34 edited
4 moved

Legend:

Unmodified
Added
Removed
  • kernel/arch/amd64/src/amd64.c

    r44b7783 rc2417bc  
    198198         * module and connect it to i8042. Enable keyboard interrupts.
    199199         */
    200         indev_t *kbrdin = i8042_init((i8042_t *) I8042_BASE, IRQ_KBD);
    201         if (kbrdin) {
    202                 kbrd_init(kbrdin);
    203                 trap_virtual_enable_irqs(1 << IRQ_KBD);
     200        i8042_instance_t *i8042_instance = i8042_init((i8042_t *) I8042_BASE, IRQ_KBD);
     201        if (i8042_instance) {
     202                kbrd_instance_t *kbrd_instance = kbrd_init();
     203                if (kbrd_instance) {
     204                        indev_t *sink = stdin_wire();
     205                        indev_t *kbrd = kbrd_wire(kbrd_instance, sink);
     206                        i8042_wire(i8042_instance, kbrd);
     207                        trap_virtual_enable_irqs(1 << IRQ_KBD);
     208                }
    204209        }
    205210       
  • kernel/arch/arm32/Makefile.inc

    r44b7783 rc2417bc  
    5252        arch/$(KARCH)/src/ddi/ddi.c \
    5353        arch/$(KARCH)/src/interrupt.c \
    54         arch/$(KARCH)/src/console.c \
    5554        arch/$(KARCH)/src/exception.c \
    5655        arch/$(KARCH)/src/userspace.c \
  • kernel/arch/arm32/src/arm32.c

    r44b7783 rc2417bc  
    3636#include <arch.h>
    3737#include <config.h>
    38 #include <arch/console.h>
    3938#include <genarch/fb/fb.h>
    4039#include <genarch/fb/visuals.h>
     
    4342#include <genarch/srln/srln.h>
    4443#include <sysinfo/sysinfo.h>
     44#include <console/console.h>
    4545#include <ddi/irq.h>
    4646#include <arch/drivers/gxemul.h>
     
    130130        /*
    131131         * Initialize the GXemul keyboard port. Then initialize the serial line
    132          * module and connect it to the GXemul keyboard. Enable keyboard interrupts.
     132         * module and connect it to the GXemul keyboard.
    133133         */
    134         indev_t *kbrdin = dsrlnin_init((dsrlnin_t *) gxemul_kbd, GXEMUL_KBD_IRQ);
    135         if (kbrdin)
    136                 srln_init(kbrdin);
     134        dsrlnin_instance_t *dsrlnin_instance
     135            = dsrlnin_init((dsrlnin_t *) gxemul_kbd, GXEMUL_KBD_IRQ);
     136        if (dsrlnin_instance) {
     137                srln_instance_t *srln_instance = srln_init();
     138                if (srln_instance) {
     139                        indev_t *sink = stdin_wire();
     140                        indev_t *srln = srln_wire(srln_instance, sink);
     141                        dsrlnin_wire(dsrlnin_instance, srln);
     142                }
     143        }
    137144       
    138145        /*
     
    202209}
    203210
     211/** Acquire console back for kernel. */
     212void arch_grab_console(void)
     213{
     214#ifdef CONFIG_FB
     215        fb_redraw();
     216#endif
     217}
     218
     219/** Return console to userspace. */
     220void arch_release_console(void)
     221{
     222}
     223
    204224/** @}
    205225 */
  • kernel/arch/ia32/src/ia32.c

    r44b7783 rc2417bc  
    8181{
    8282        /* Parse multiboot information obtained from the bootloader. */
    83         multiboot_info_parse(signature, mi);   
     83        multiboot_info_parse(signature, mi);
    8484       
    8585#ifdef CONFIG_SMP
     
    156156         * module and connect it to i8042. Enable keyboard interrupts.
    157157         */
    158         indev_t *kbrdin = i8042_init((i8042_t *) I8042_BASE, IRQ_KBD);
    159         if (kbrdin) {
    160                 kbrd_init(kbrdin);
    161                 trap_virtual_enable_irqs(1 << IRQ_KBD);
     158        i8042_instance_t *i8042_instance = i8042_init((i8042_t *) I8042_BASE, IRQ_KBD);
     159        if (i8042_instance) {
     160                kbrd_instance_t *kbrd_instance = kbrd_init();
     161                if (kbrd_instance) {
     162                        indev_t *sink = stdin_wire();
     163                        indev_t *kbrd = kbrd_wire(kbrd_instance, sink);
     164                        i8042_wire(i8042_instance, kbrd);
     165                        trap_virtual_enable_irqs(1 << IRQ_KBD);
     166                }
    162167        }
    163168       
  • kernel/arch/ia64/Makefile.inc

    r44b7783 rc2417bc  
    6565
    6666ifeq ($(MACHINE),ski)
    67         ARCH_SOURCES += arch/$(KARCH)/src/ski/ski.c
    68         DEFS += -DSKI
     67        ARCH_SOURCES += arch/$(KARCH)/src/drivers/ski.c
    6968        BFD = binary
    7069endif
  • kernel/arch/ia64/include/arch.h

    r44b7783 rc2417bc  
    2727 */
    2828
    29 /** @addtogroup ia64   
     29/** @addtogroup ia64
    3030 * @{
    3131 */
     
    3838#define LOADED_PROG_STACK_PAGES_NO 2
    3939
    40 #include <arch/ski/ski.h>
     40#include <arch/drivers/ski.h>
    4141
    4242extern void arch_pre_main(void);
  • kernel/arch/ia64/include/drivers/ski.h

    r44b7783 rc2417bc  
    2727 */
    2828
    29 /** @addtogroup ia64   
     29/** @addtogroup ia64
    3030 * @{
    3131 */
     
    3737
    3838#include <console/chardev.h>
     39#include <proc/thread.h>
    3940
    40 #define SKI_INIT_CONSOLE        20
    41 #define SKI_GETCHAR             21
    42 #define SKI_PUTCHAR             31
     41typedef struct {
     42        thread_t *thread;
     43        indev_t *srlnin;
     44} ski_instance_t;
    4345
    44 extern indev_t *skiin_init(void);
    4546extern void skiout_init(void);
     47
     48extern ski_instance_t *skiin_init(void);
     49extern void skiin_wire(ski_instance_t *, indev_t *);
    4650extern void ski_kbd_grab(void);
    4751extern void ski_kbd_release(void);
  • kernel/arch/ia64/src/drivers/ski.c

    r44b7783 rc2417bc  
    3333 */
    3434
    35 #include <arch/ski/ski.h>
     35#include <arch/drivers/ski.h>
    3636#include <console/console.h>
    3737#include <console/chardev.h>
     
    4545#include <arch.h>
    4646
    47 static indev_t skiin;           /**< Ski input device. */
    48 static outdev_t skiout;         /**< Ski output device. */
    49 
    50 static bool kbd_disabled;
     47#define POLL_INTERVAL  10000  /* 10 ms */
     48
     49#define SKI_INIT_CONSOLE  20
     50#define SKI_GETCHAR       21
     51#define SKI_PUTCHAR       31
     52
     53static void ski_putchar(outdev_t *, const wchar_t, bool);
     54
     55static outdev_operations_t skiout_ops = {
     56        .write = ski_putchar
     57};
     58
     59static outdev_t skiout;            /**< Ski output device. */
     60static bool initialized = false;
     61static bool kbd_disabled = false;
     62
     63/** Initialize debug console
     64 *
     65 * Issue SSC (Simulator System Call) to
     66 * to open debug console.
     67 *
     68 */
     69static void ski_init(void)
     70{
     71        if (initialized)
     72                return;
     73       
     74        asm volatile (
     75                "mov r15 = %0\n"
     76                "break 0x80000\n"
     77                :
     78                : "i" (SKI_INIT_CONSOLE)
     79                : "r15", "r8"
     80        );
     81       
     82        initialized = true;
     83}
    5184
    5285static void ski_do_putchar(const wchar_t ch)
     
    5588                "mov r15 = %[cmd]\n"
    5689                "mov r32 = %[ch]\n"   /* r32 is in0 */
    57                 "break 0x80000\n"  /* modifies r8 */
     90                "break 0x80000\n"     /* modifies r8 */
    5891                :
    5992                : [cmd] "i" (SKI_PUTCHAR), [ch] "r" (ch)
     
    67100 * display character on debug console.
    68101 *
    69  * @param d Character device.
    70  * @param ch Character to be printed.
    71  */
    72 static void ski_putchar(outdev_t *d, const wchar_t ch, bool silent)
     102 * @param dev    Character device.
     103 * @param ch     Character to be printed.
     104 * @param silent Whether the output should be silenced.
     105 *
     106 */
     107static void ski_putchar(outdev_t *dev, const wchar_t ch, bool silent)
    73108{
    74109        if (!silent) {
     
    79114                        ski_do_putchar(ch);
    80115                } else
    81                         ski_do_putchar(SPECIAL);
     116                        ski_do_putchar(U_SPECIAL);
    82117        }
    83118}
    84119
    85 static indev_operations_t skiin_ops = {
    86         .poll = NULL
    87 };
    88 
    89 static outdev_operations_t skiout_ops = {
    90         .write = ski_putchar
    91 };
     120void skiout_init(void)
     121{
     122        ski_init();
     123       
     124        outdev_initialize("skiout", &skiout, &skiout_ops);
     125        stdout = &skiout;
     126       
     127        sysinfo_set_item_val("fb", NULL, false);
     128}
    92129
    93130/** Ask debug console if a key was pressed.
     
    99136 *
    100137 * @return ASCII code of pressed key or 0 if no key pressed.
    101  */
    102 static int32_t ski_getchar(void)
     138 *
     139 */
     140static wchar_t ski_getchar(void)
    103141{
    104142        uint64_t ch;
     
    106144        asm volatile (
    107145                "mov r15 = %1\n"
    108                 "break 0x80000;;\n"     /* modifies r8 */
    109                 "mov %0 = r8;;\n"               
    110 
     146                "break 0x80000;;\n"  /* modifies r8 */
     147                "mov %0 = r8;;\n"
     148               
    111149                : "=r" (ch)
    112150                : "i" (SKI_GETCHAR)
    113151                : "r15", "r8"
    114152        );
    115 
    116         return (int32_t) ch;
     153       
     154        return (wchar_t) ch;
    117155}
    118156
    119157/** Ask keyboard if a key was pressed. */
    120 static void poll_keyboard(void)
    121 {
    122         char ch;
    123        
     158static void poll_keyboard(ski_instance_t *instance)
     159{
    124160        if (kbd_disabled)
    125161                return;
    126         ch = ski_getchar();
    127         if(ch == '\r')
    128                 ch = '\n';
    129         if (ch) {
    130                 indev_push_character(&skiin, ch);
    131                 return;
    132         }
    133 }
    134 
    135 #define POLL_INTERVAL           10000           /* 10 ms */
     162       
     163        wchar_t ch = ski_getchar();
     164       
     165        if (ch != 0)
     166                indev_push_character(instance->srlnin, ch);
     167}
    136168
    137169/** Kernel thread for polling keyboard. */
    138 static void kkbdpoll(void *arg)
    139 {
    140         while (1) {
    141                 if (!silent) {
    142                         poll_keyboard();
    143                 }
     170static void kskipoll(void *arg)
     171{
     172        ski_instance_t *instance = (ski_instance_t *) arg;
     173       
     174        while (true) {
     175                if (!silent)
     176                        poll_keyboard(instance);
     177               
    144178                thread_usleep(POLL_INTERVAL);
    145179        }
    146180}
    147181
    148 /** Initialize debug console
    149  *
    150  * Issue SSC (Simulator System Call) to
    151  * to open debug console.
    152  */
    153 static void ski_init(void)
    154 {
    155         static bool initialized;
    156 
    157         if (initialized)
    158                 return;
    159        
    160         asm volatile (
    161                 "mov r15 = %0\n"
    162                 "break 0x80000\n"
    163                 :
    164                 : "i" (SKI_INIT_CONSOLE)
    165                 : "r15", "r8"
    166         );
    167        
    168         initialized = true;
    169 }
    170 
    171 indev_t *skiin_init(void)
     182ski_instance_t *skiin_init(void)
    172183{
    173184        ski_init();
    174 
    175         indev_initialize("skiin", &skiin, &skiin_ops);
    176         thread_t *t = thread_create(kkbdpoll, NULL, TASK, 0, "kkbdpoll", true);
    177         if (t)
    178                 thread_ready(t);
    179         else
    180                 return NULL;
    181 
     185       
     186        ski_instance_t *instance
     187            = malloc(sizeof(ski_instance_t), FRAME_ATOMIC);
     188       
     189        if (instance) {
     190                instance->thread = thread_create(kskipoll, (void *) instance, TASK, 0, "kskipoll", true);
     191               
     192                if (!instance->thread) {
     193                        free(instance);
     194                        return NULL;
     195                }
     196               
     197                instance->srlnin = NULL;
     198        }
     199       
     200        return instance;
     201}
     202
     203void skiin_wire(ski_instance_t *instance, indev_t *srlnin)
     204{
     205        ASSERT(instance);
     206        ASSERT(srlnin);
     207       
     208        instance->srlnin = srlnin;
     209        thread_ready(instance->thread);
     210       
    182211        sysinfo_set_item_val("kbd", NULL, true);
    183212        sysinfo_set_item_val("kbd.type", NULL, KBD_SKI);
    184 
    185         return &skiin;
    186 }
    187 
    188 
    189 void skiout_init(void)
    190 {
    191         ski_init();
    192 
    193         outdev_initialize("skiout", &skiout, &skiout_ops);
    194         stdout = &skiout;
    195 
    196         sysinfo_set_item_val("fb", NULL, false);
    197213}
    198214
  • kernel/arch/ia64/src/ia64.c

    r44b7783 rc2417bc  
    3434
    3535#include <arch.h>
    36 #include <arch/ski/ski.h>
     36#include <arch/drivers/ski.h>
    3737#include <arch/drivers/it.h>
    3838#include <arch/interrupt.h>
     
    149149void arch_post_smp_init(void)
    150150{
    151 #ifdef SKI
    152         indev_t *in;
    153         in = skiin_init();
    154         if (in)
    155                 srln_init(in);
     151#ifdef MACHINE_ski
     152        ski_instance_t *ski_instance = skiin_init();
     153        if (ski_instance) {
     154                srln_instance_t *srln_instance = srln_init();
     155                if (srln_instance) {
     156                        indev_t *sink = stdin_wire();
     157                        indev_t *srln = srln_wire(srln_instance, sink);
     158                        skiin_wire(ski_instance, srln);
     159                }
     160        }
     161       
    156162        skiout_init();
    157163#endif
     
    162168       
    163169#ifdef CONFIG_NS16550
    164         indev_t *kbrdin_ns16550
     170        ns16550_instance_t *ns16550_instance
    165171            = ns16550_init((ns16550_t *) NS16550_BASE, NS16550_IRQ, NULL, NULL);
    166         if (kbrdin_ns16550)
    167                 srln_init(kbrdin_ns16550);
     172        if (ns16550_instance) {
     173                srln_instance_t *srln_instance = srln_init();
     174                if (srln_instance) {
     175                        indev_t *sink = stdin_wire();
     176                        indev_t *srln = srln_wire(srln_instance, sink);
     177                        ns16550_wire(ns16550_instance, srln);
     178                }
     179        }
    168180       
    169181        sysinfo_set_item_val("kbd", NULL, true);
     
    177189       
    178190#ifdef CONFIG_I8042
    179         indev_t *kbrdin_i8042 = i8042_init((i8042_t *) I8042_BASE, IRQ_KBD);
    180         if (kbrdin_i8042)
    181                 kbrd_init(kbrdin_i8042);
     191        i8042_instance_t *i8042_instance = i8042_init((i8042_t *) I8042_BASE, IRQ_KBD);
     192        if (i8042_instance) {
     193                kbrd_instance_t *kbrd_instance = kbrd_init();
     194                if (kbrd_instance) {
     195                        indev_t *sink = stdin_wire();
     196                        indev_t *kbrd = kbrd_wire(kbrd_instance, sink);
     197                        i8042_wire(i8042_instance, kbrd);
     198                }
     199        }
    182200       
    183201        sysinfo_set_item_val("kbd", NULL, true);
     
    239257void arch_grab_console(void)
    240258{
    241 #ifdef SKI
     259#ifdef MACHINE_ski
    242260        ski_kbd_grab();
    243261#endif
     
    249267void arch_release_console(void)
    250268{
    251 #ifdef SKI
     269#ifdef MACHINE_ski
    252270        ski_kbd_release();
    253271#endif
  • kernel/arch/ia64/src/smp/smp.c

    r44b7783 rc2417bc  
    3434
    3535#include <arch.h>
    36 #include <arch/ski/ski.h>
     36#include <arch/drivers/ski.h>
    3737#include <arch/drivers/it.h>
    3838#include <arch/interrupt.h>
  • kernel/arch/mips32/Makefile.inc

    r44b7783 rc2417bc  
    6161        arch/$(KARCH)/src/panic.S \
    6262        arch/$(KARCH)/src/mips32.c \
    63         arch/$(KARCH)/src/console.c \
    6463        arch/$(KARCH)/src/asm.S \
    6564        arch/$(KARCH)/src/exception.c \
  • kernel/arch/mips32/src/mips32.c

    r44b7783 rc2417bc  
    3737#include <arch/exception.h>
    3838#include <mm/as.h>
    39 
    4039#include <userspace.h>
    41 #include <arch/console.h>
    4240#include <memstr.h>
    4341#include <proc/thread.h>
    4442#include <proc/uarg.h>
    4543#include <print.h>
     44#include <console/console.h>
    4645#include <syscall/syscall.h>
    4746#include <sysinfo/sysinfo.h>
    48 
    4947#include <arch/interrupt.h>
    5048#include <console/chardev.h>
     
    6058#include <string.h>
    6159#include <arch/drivers/msim.h>
    62 
    6360#include <arch/asm/regname.h>
    6461
     
    170167         * module and connect it to the msim/GXemul keyboard. Enable keyboard interrupts.
    171168         */
    172         indev_t *kbrdin = dsrlnin_init((dsrlnin_t *) MSIM_KBD_ADDRESS, MSIM_KBD_IRQ);
    173         if (kbrdin) {
    174                 srln_init(kbrdin);
    175                 cp0_unmask_int(MSIM_KBD_IRQ);
     169        dsrlnin_instance_t *dsrlnin_instance
     170            = dsrlnin_init((dsrlnin_t *) MSIM_KBD_ADDRESS, MSIM_KBD_IRQ);
     171        if (dsrlnin_instance) {
     172                srln_instance_t *srln_instance = srln_init();
     173                if (srln_instance) {
     174                        indev_t *sink = stdin_wire();
     175                        indev_t *srln = srln_wire(srln_instance, sink);
     176                        dsrlnin_wire(dsrlnin_instance, srln);
     177                        cp0_unmask_int(MSIM_KBD_IRQ);
     178                }
    176179        }
    177180       
     
    249252}
    250253
     254void arch_grab_console(void)
     255{
     256#ifdef CONFIG_FB
     257        fb_redraw();
     258#endif
     259}
     260
     261/** Return console to userspace
     262 *
     263 */
     264void arch_release_console(void)
     265{
     266}
     267
    251268/** @}
    252269 */
  • kernel/arch/ppc32/Makefile.inc

    r44b7783 rc2417bc  
    5555        arch/$(KARCH)/src/proc/scheduler.c \
    5656        arch/$(KARCH)/src/ddi/ddi.c \
    57         arch/$(KARCH)/src/drivers/cuda.c \
    5857        arch/$(KARCH)/src/mm/as.c \
    5958        arch/$(KARCH)/src/mm/frame.c \
  • kernel/arch/ppc32/include/drivers/pic.h

    r44b7783 rc2417bc  
    2727 */
    2828
    29 /** @addtogroup ppc32   
     29/** @addtogroup ppc32
    3030 * @{
    3131 */
     
    3737
    3838#include <arch/types.h>
     39#include <ddi/irq.h>
    3940
    4041#define PIC_PENDING_LOW    8
     
    4546#define PIC_ACK_HIGH       6
    4647
    47 void pic_init(uintptr_t base, size_t size);
    48 void pic_enable_interrupt(int intnum);
    49 void pic_disable_interrupt(int intnum);
    50 void pic_ack_interrupt(int intnum);
    51 int pic_get_pending(void);
     48extern void pic_init(uintptr_t base, size_t size, cir_t *cir, void **cir_arg);
     49extern void pic_enable_interrupt(inr_t intnum);
     50extern void pic_disable_interrupt(inr_t intnum);
     51extern void pic_ack_interrupt(void *arg, inr_t intnum);
     52extern int pic_get_pending(void);
    5253
    5354#endif
  • kernel/arch/ppc32/src/drivers/pic.c

    r44b7783 rc2417bc  
    2727 */
    2828
    29 /** @addtogroup ppc32   
     29/** @addtogroup ppc32
    3030 * @{
    3131 */
     
    4141static volatile uint32_t *pic = NULL;
    4242
    43 void pic_init(uintptr_t base, size_t size)
     43void pic_init(uintptr_t base, size_t size, cir_t *cir, void **cir_arg)
    4444{
    4545        pic = (uint32_t *) hw_map(base, size);
     46        *cir = pic_ack_interrupt;
     47        *cir_arg = NULL;
    4648}
    4749
    48 void pic_enable_interrupt(int intnum)
     50void pic_enable_interrupt(inr_t intnum)
    4951{
    5052        if (pic) {
     
    5759}
    5860
    59 void pic_disable_interrupt(int intnum)
     61void pic_disable_interrupt(inr_t intnum)
    6062{
    6163        if (pic) {
     
    6769}
    6870
    69 void pic_ack_interrupt(int intnum)
     71void pic_ack_interrupt(void *arg, inr_t intnum)
    7072{
    7173        if (pic) {
  • kernel/arch/ppc32/src/dummy.s

    r44b7783 rc2417bc  
    3131.global asm_delay_loop
    3232.global sys_tls_set
     33.global cpu_halt
    3334
    3435sys_tls_set:
     
    3738asm_delay_loop:
    3839        blr
     40
     41cpu_halt:
     42        b cpu_halt
  • kernel/arch/ppc32/src/interrupt.c

    r44b7783 rc2417bc  
    6161       
    6262        while ((inum = pic_get_pending()) != -1) {
    63                 bool ack = false;
    6463                irq_t *irq = irq_dispatch_and_lock(inum);
    6564                if (irq) {
     
    7069                        if (irq->preack) {
    7170                                /* Acknowledge the interrupt before processing */
    72                                 pic_ack_interrupt(inum);
    73                                 ack = true;
     71                                if (irq->cir)
     72                                        irq->cir(irq->cir_arg, irq->inr);
    7473                        }
    7574                       
    7675                        irq->handler(irq);
     76                       
     77                        if (!irq->preack) {
     78                                if (irq->cir)
     79                                        irq->cir(irq->cir_arg, irq->inr);
     80                        }
     81                       
    7782                        spinlock_unlock(&irq->lock);
    7883                } else {
     
    8489#endif
    8590                }
    86                
    87                 if (!ack)
    88                         pic_ack_interrupt(inum);
    8991        }
    9092}
  • kernel/arch/ppc32/src/ppc32.c

    r44b7783 rc2417bc  
    3636#include <arch.h>
    3737#include <arch/boot/boot.h>
    38 #include <arch/drivers/cuda.h>
     38#include <genarch/drivers/via-cuda/cuda.h>
    3939#include <arch/interrupt.h>
    4040#include <genarch/fb/fb.h>
     
    4545#include <ddi/irq.h>
    4646#include <arch/drivers/pic.h>
     47#include <align.h>
    4748#include <macros.h>
    4849#include <string.h>
    4950
    5051#define IRQ_COUNT  64
     52#define IRQ_CUDA   10
    5153
    5254bootinfo_t bootinfo;
     
    118120                if (bootinfo.macio.addr) {
    119121                        /* Initialize PIC */
    120                         pic_init(bootinfo.macio.addr, PAGE_SIZE);
     122                        cir_t cir;
     123                        void *cir_arg;
     124                        pic_init(bootinfo.macio.addr, PAGE_SIZE, &cir, &cir_arg);
     125                       
     126#ifdef CONFIG_VIA_CUDA
     127                        uintptr_t pa = bootinfo.macio.addr + 0x16000;
     128                        uintptr_t aligned_addr = ALIGN_DOWN(pa, PAGE_SIZE);
     129                        size_t offset = pa - aligned_addr;
     130                        size_t size = 2 * PAGE_SIZE;
     131                       
     132                        cuda_t *cuda = (cuda_t *)
     133                            (hw_map(aligned_addr, offset + size) + offset);
    121134                       
    122135                        /* Initialize I/O controller */
    123                         cuda_init(bootinfo.macio.addr + 0x16000, 2 * PAGE_SIZE);
     136                        cuda_instance_t *cuda_instance =
     137                            cuda_init(cuda, IRQ_CUDA, cir, cir_arg);
     138                        if (cuda_instance) {
     139                                indev_t *sink = stdin_wire();
     140                                cuda_wire(cuda_instance, sink);
     141                        }
     142#endif
    124143                }
    125144               
     
    187206}
    188207
     208void arch_reboot(void)
     209{
     210        // TODO
     211        while (1);
     212}
     213
    189214/** @}
    190215 */
  • kernel/arch/sparc64/include/drivers/kbd.h

    r44b7783 rc2417bc  
    2727 */
    2828
    29 /** @addtogroup sparc64 
     29/** @addtogroup sparc64
    3030 * @{
    3131 */
     
    3939#include <genarch/ofw/ofw_tree.h>
    4040
    41 typedef enum {
    42         KBD_UNKNOWN,
    43         KBD_Z8530,
    44         KBD_NS16550,
    45         KBD_SGCN
    46 } kbd_type_t;
    47 
    48 extern kbd_type_t kbd_type;
    49 
    5041extern void kbd_init(ofw_tree_node_t *node);
    5142
  • kernel/arch/sparc64/src/console.c

    r44b7783 rc2417bc  
    2727 */
    2828
    29 /** @addtogroup sparc64 
     29/** @addtogroup sparc64
    3030 * @{
    3131 */
     
    136136#endif
    137137       
    138         switch (kbd_type) {
    139138#ifdef CONFIG_SGCN_KBD
    140         case KBD_SGCN:
    141                 sgcn_grab();
    142                 break;
     139        sgcn_grab();
    143140#endif
    144         default:
    145                 break;
    146         }
    147141}
    148142
     
    152146void arch_release_console(void)
    153147{
    154         switch (kbd_type) {
    155148#ifdef CONFIG_SGCN_KBD
    156         case KBD_SGCN:
    157                 sgcn_release();
    158                 break;
     149        sgcn_release();
    159150#endif
    160         default:
    161                 break;
    162         }
    163151}
    164152
  • kernel/arch/sparc64/src/drivers/kbd.c

    r44b7783 rc2417bc  
    5555#include <sysinfo/sysinfo.h>
    5656
    57 kbd_type_t kbd_type = KBD_UNKNOWN;
    58 
    5957#ifdef CONFIG_SUN_KBD
    6058
    61 /** Initialize keyboard.
    62  *
    63  * Traverse OpenFirmware device tree in order to find necessary
    64  * info about the keyboard device.
    65  *
    66  * @param node Keyboard device node.
    67  */
    68 void kbd_init(ofw_tree_node_t *node)
     59#ifdef CONFIG_Z8530
     60
     61static bool kbd_z8530_init(ofw_tree_node_t *node)
    6962{
    70         size_t offset;
    71         uintptr_t aligned_addr;
    72         ofw_tree_property_t *prop;
    73         const char *name;
     63        const char *name = ofw_tree_node_name(node);
     64       
     65        if (str_cmp(name, "zs") != 0)
     66                return false;
     67       
     68        /*
     69         * Read 'interrupts' property.
     70         */
     71        ofw_tree_property_t *prop = ofw_tree_getprop(node, "interrupts");
     72        if ((!prop) || (!prop->value)) {
     73                printf("z8530: Unable to find interrupts property\n");
     74                return false;
     75        }
     76       
     77        uint32_t interrupts = *((uint32_t *) prop->value);
     78       
     79        /*
     80         * Read 'reg' property.
     81         */
     82        prop = ofw_tree_getprop(node, "reg");
     83        if ((!prop) || (!prop->value)) {
     84                printf("z8530: Unable to find reg property\n");
     85                return false;
     86        }
     87       
     88        size_t size = ((ofw_fhc_reg_t *) prop->value)->size;
     89       
     90        uintptr_t pa;
     91        if (!ofw_fhc_apply_ranges(node->parent,
     92            ((ofw_fhc_reg_t *) prop->value), &pa)) {
     93                printf("z8530: Failed to determine address\n");
     94                return false;
     95        }
     96       
     97        inr_t inr;
    7498        cir_t cir;
    7599        void *cir_arg;
    76        
    77 #ifdef CONFIG_NS16550
    78         ns16550_t *ns16550;
    79 #endif
    80 #ifdef CONFIG_Z8530
    81         z8530_t *z8530;
    82 #endif
    83        
    84         name = ofw_tree_node_name(node);
    85        
    86         /*
    87          * Determine keyboard serial controller type.
    88          */
    89         if (str_cmp(name, "zs") == 0)
    90                 kbd_type = KBD_Z8530;
    91         else if (str_cmp(name, "su") == 0)
    92                 kbd_type = KBD_NS16550;
    93        
    94         if (kbd_type == KBD_UNKNOWN) {
    95                 printf("Unknown keyboard device.\n");
    96                 return;
    97         }
    98        
    99         /*
    100          * Read 'interrupts' property.
    101          */
    102         uint32_t interrupts;
    103         prop = ofw_tree_getprop(node, "interrupts");
    104         if ((!prop) || (!prop->value))
    105                 panic("Cannot find 'interrupt' property.");
    106         interrupts = *((uint32_t *) prop->value);
    107        
    108         /*
    109          * Read 'reg' property.
    110          */
    111         prop = ofw_tree_getprop(node, "reg");
    112         if ((!prop) || (!prop->value))
    113                 panic("Cannot find 'reg' property.");
    114        
    115         uintptr_t pa;
    116         size_t size;
    117         inr_t inr;
    118        
    119         switch (kbd_type) {
    120         case KBD_Z8530:
    121                 size = ((ofw_fhc_reg_t *) prop->value)->size;
    122                 if (!ofw_fhc_apply_ranges(node->parent,
    123                     ((ofw_fhc_reg_t *) prop->value), &pa)) {
    124                         printf("Failed to determine keyboard address.\n");
    125                         return;
    126                 }
    127                 if (!ofw_fhc_map_interrupt(node->parent,
    128                     ((ofw_fhc_reg_t *) prop->value), interrupts, &inr, &cir,
    129                     &cir_arg)) {
    130                         printf("Failed to determine keyboard interrupt.\n");
    131                         return;
    132                 }
    133                 break;
    134                
    135         case KBD_NS16550:
    136                 size = ((ofw_ebus_reg_t *) prop->value)->size;
    137                 if (!ofw_ebus_apply_ranges(node->parent,
    138                     ((ofw_ebus_reg_t *) prop->value), &pa)) {
    139                         printf("Failed to determine keyboard address.\n");
    140                         return;
    141                 }
    142                 if (!ofw_ebus_map_interrupt(node->parent,
    143                     ((ofw_ebus_reg_t *) prop->value), interrupts, &inr, &cir,
    144                     &cir_arg)) {
    145                         printf("Failed to determine keyboard interrupt.\n");
    146                         return;
    147                 };
    148                 break;
    149         default:
    150                 panic("Unexpected keyboard type.");
     100        if (!ofw_fhc_map_interrupt(node->parent,
     101            ((ofw_fhc_reg_t *) prop->value), interrupts, &inr, &cir,
     102            &cir_arg)) {
     103                printf("z8530: Failed to determine interrupt\n");
     104                return false;
    151105        }
    152106       
     
    157111         * underlying controller.
    158112         */
    159         aligned_addr = ALIGN_DOWN(pa, PAGE_SIZE);
    160         offset = pa - aligned_addr;
    161        
    162         switch (kbd_type) {
     113        uintptr_t aligned_addr = ALIGN_DOWN(pa, PAGE_SIZE);
     114        size_t offset = pa - aligned_addr;
     115       
     116        z8530_t *z8530 = (z8530_t *)
     117            (hw_map(aligned_addr, offset + size) + offset);
     118       
     119        z8530_instance_t *z8530_instance = z8530_init(z8530, inr, cir, cir_arg);
     120        if (z8530_instance) {
     121                kbrd_instance_t *kbrd_instance = kbrd_init();
     122                if (kbrd_instance) {
     123                        indev_t *sink = stdin_wire();
     124                        indev_t *kbrd = kbrd_wire(kbrd_instance, sink);
     125                        z8530_wire(z8530_instance, kbrd);
     126                }
     127        }
     128       
     129        /*
     130         * This is the necessary evil until the userspace drivers are
     131         * entirely self-sufficient.
     132         */
     133        sysinfo_set_item_val("kbd", NULL, true);
     134        sysinfo_set_item_val("kbd.inr", NULL, inr);
     135        sysinfo_set_item_val("kbd.address.kernel", NULL,
     136            (uintptr_t) z8530);
     137        sysinfo_set_item_val("kbd.address.physical", NULL, pa);
     138        sysinfo_set_item_val("kbd.type.z8530", NULL, true);
     139       
     140        return true;
     141}
     142
     143#endif /* CONFIG_Z8530 */
     144
     145#ifdef CONFIG_NS16550
     146
     147static bool kbd_ns16550_init(ofw_tree_node_t *node)
     148{
     149        const char *name = ofw_tree_node_name(node);
     150       
     151        if (str_cmp(name, "su") != 0)
     152                return false;
     153       
     154        /*
     155         * Read 'interrupts' property.
     156         */
     157        ofw_tree_property_t *prop = ofw_tree_getprop(node, "interrupts");
     158        if ((!prop) || (!prop->value)) {
     159                printf("ns16550: Unable to find interrupts property\n");
     160                return false;
     161        }
     162       
     163        uint32_t interrupts = *((uint32_t *) prop->value);
     164       
     165        /*
     166         * Read 'reg' property.
     167         */
     168        prop = ofw_tree_getprop(node, "reg");
     169        if ((!prop) || (!prop->value)) {
     170                printf("ns16550: Unable to find reg property\n");
     171                return false;
     172        }
     173       
     174        size_t size = ((ofw_ebus_reg_t *) prop->value)->size;
     175       
     176        uintptr_t pa;
     177        if (!ofw_ebus_apply_ranges(node->parent,
     178            ((ofw_ebus_reg_t *) prop->value), &pa)) {
     179                printf("ns16550: Failed to determine address\n");
     180                return false;
     181        }
     182       
     183        inr_t inr;
     184        cir_t cir;
     185        void *cir_arg;
     186        if (!ofw_ebus_map_interrupt(node->parent,
     187            ((ofw_ebus_reg_t *) prop->value), interrupts, &inr, &cir,
     188            &cir_arg)) {
     189                printf("ns16550: Failed to determine interrupt\n");
     190                return false;
     191        }
     192       
     193        /*
     194         * We need to pass aligned address to hw_map().
     195         * However, the physical keyboard address can
     196         * be pretty much unaligned, depending on the
     197         * underlying controller.
     198         */
     199        uintptr_t aligned_addr = ALIGN_DOWN(pa, PAGE_SIZE);
     200        size_t offset = pa - aligned_addr;
     201       
     202        ns16550_t *ns16550 = (ns16550_t *)
     203           (hw_map(aligned_addr, offset + size) + offset);
     204       
     205        ns16550_instance_t *ns16550_instance = ns16550_init(ns16550, inr, cir, cir_arg);
     206        if (ns16550_instance) {
     207                kbrd_instance_t *kbrd_instance = kbrd_init();
     208                if (kbrd_instance) {
     209                        indev_t *sink = stdin_wire();
     210                        indev_t *kbrd = kbrd_wire(kbrd_instance, sink);
     211                        ns16550_wire(ns16550_instance, kbrd);
     212                }
     213        }
     214       
     215        /*
     216         * This is the necessary evil until the userspace drivers are
     217         * entirely self-sufficient.
     218         */
     219        sysinfo_set_item_val("kbd", NULL, true);
     220        sysinfo_set_item_val("kbd.inr", NULL, inr);
     221        sysinfo_set_item_val("kbd.address.kernel", NULL,
     222            (uintptr_t) ns16550);
     223        sysinfo_set_item_val("kbd.address.physical", NULL, pa);
     224        sysinfo_set_item_val("kbd.type.ns16550", NULL, true);
     225       
     226        return true;
     227}
     228
     229#endif /* CONFIG_NS16550 */
     230
     231/** Initialize keyboard.
     232 *
     233 * Traverse OpenFirmware device tree in order to find necessary
     234 * info about the keyboard device.
     235 *
     236 * @param node Keyboard device node.
     237 *
     238 */
     239void kbd_init(ofw_tree_node_t *node)
     240{
    163241#ifdef CONFIG_Z8530
    164         case KBD_Z8530:
    165                 z8530 = (z8530_t *)
    166                     (hw_map(aligned_addr, offset + size) + offset);
    167                
    168                 indev_t *kbrdin_z8530 = z8530_init(z8530, inr, cir, cir_arg);
    169                 if (kbrdin_z8530)
    170                         kbrd_init(kbrdin_z8530);
    171                
    172                 /*
    173                  * This is the necessary evil until the userspace drivers are
    174                  * entirely self-sufficient.
    175                  */
    176                 sysinfo_set_item_val("kbd", NULL, true);
    177                 sysinfo_set_item_val("kbd.type", NULL, KBD_Z8530);
    178                 sysinfo_set_item_val("kbd.inr", NULL, inr);
    179                 sysinfo_set_item_val("kbd.address.kernel", NULL,
    180                     (uintptr_t) z8530);
    181                 sysinfo_set_item_val("kbd.address.physical", NULL, pa);
    182                 break;
    183 #endif
     242        kbd_z8530_init(node);
     243#endif
     244       
    184245#ifdef CONFIG_NS16550
    185         case KBD_NS16550:
    186                 ns16550 = (ns16550_t *)
    187                    (hw_map(aligned_addr, offset + size) + offset);
    188                
    189                 indev_t *kbrdin_ns16550 = ns16550_init(ns16550, inr, cir, cir_arg);
    190                 if (kbrdin_ns16550)
    191                         kbrd_init(kbrdin_ns16550);
    192                
    193                 /*
    194                  * This is the necessary evil until the userspace driver is
    195                  * entirely self-sufficient.
    196                  */
    197                 sysinfo_set_item_val("kbd", NULL, true);
    198                 sysinfo_set_item_val("kbd.type", NULL, KBD_NS16550);
    199                 sysinfo_set_item_val("kbd.inr", NULL, inr);
    200                 sysinfo_set_item_val("kbd.address.kernel", NULL,
    201                     (uintptr_t) ns16550);
    202                 sysinfo_set_item_val("kbd.address.physical", NULL, pa);
    203                 break;
    204 #endif
    205         default:
    206                 printf("Kernel is not compiled with the necessary keyboard "
    207                     "driver this machine requires.\n");
    208         }
     246        kbd_ns16550_init(node);
     247#endif
    209248}
    210249
    211 #endif
     250#endif /* CONFIG_SUN_KBD */
    212251
    213252/** @}
  • kernel/arch/sparc64/src/drivers/sgcn.c

    r44b7783 rc2417bc  
    101101/** Returns a pointer to the console buffer header. */
    102102#define SGCN_BUFFER_HEADER      (SGCN_BUFFER(sgcn_buffer_header_t, 0))
    103 
    104 /** defined in drivers/kbd.c */
    105 extern kbd_type_t kbd_type;
    106103
    107104/** starting address of SRAM, will be set by the init_sram_begin function */
     
    354351        sgcn_buffer_begin_init();
    355352
    356         kbd_type = KBD_SGCN;
    357 
    358353        sysinfo_set_item_val("kbd", NULL, true);
    359         sysinfo_set_item_val("kbd.type", NULL, KBD_SGCN);
    360354
    361355        thread_t *t = thread_create(kkbdpoll, NULL, TASK, 0, "kkbdpoll", true);
  • kernel/genarch/Makefile.inc

    r44b7783 rc2417bc  
    9494endif
    9595
     96ifeq ($(CONFIG_VIA_CUDA),y)
     97        GENARCH_SOURCES += \
     98                genarch/src/drivers/via-cuda/cuda.c
     99endif
     100
    96101ifeq ($(CONFIG_PC_KBD),y)
    97102        GENARCH_SOURCES += \
  • kernel/genarch/include/drivers/dsrln/dsrlnin.h

    r44b7783 rc2417bc  
    5050        irq_t irq;
    5151        dsrlnin_t *dsrlnin;
    52         indev_t kbrdin;
     52        indev_t *srlnin;
    5353} dsrlnin_instance_t;
    5454
    55 extern indev_t *dsrlnin_init(dsrlnin_t *, inr_t);
     55extern dsrlnin_instance_t *dsrlnin_init(dsrlnin_t *, inr_t);
     56extern void dsrlnin_wire(dsrlnin_instance_t *, indev_t *);
    5657
    5758#endif
  • kernel/genarch/include/drivers/i8042/i8042.h

    r44b7783 rc2417bc  
    5050        irq_t irq;
    5151        i8042_t *i8042;
    52         indev_t kbrdin;
     52        indev_t *kbrdin;
    5353} i8042_instance_t;
    5454
    55 extern indev_t *i8042_init(i8042_t *, inr_t);
     55extern i8042_instance_t *i8042_init(i8042_t *, inr_t);
     56extern void i8042_wire(i8042_instance_t *, indev_t *);
    5657extern void i8042_cpu_reset(i8042_t *);
    5758
  • kernel/genarch/include/drivers/ns16550/ns16550.h

    r44b7783 rc2417bc  
    6363/** Structure representing the ns16550 device. */
    6464typedef struct {
     65        irq_t irq;
    6566        ns16550_t *ns16550;
    66         irq_t irq;
    67         indev_t kbrdin;
     67        indev_t *kbrdin;
    6868} ns16550_instance_t;
    6969
    70 extern indev_t *ns16550_init(ns16550_t *, inr_t, cir_t, void *);
     70extern ns16550_instance_t *ns16550_init(ns16550_t *, inr_t, cir_t, void *);
     71extern void ns16550_wire(ns16550_instance_t *, indev_t *);
    7172
    7273#endif
  • kernel/genarch/include/drivers/via-cuda/cuda.h

    r44b7783 rc2417bc  
    2727 */
    2828
    29 /** @addtogroup ppc32   
     29/** @addtogroup genarch
    3030 * @{
    3131 */
     
    3333 */
    3434
    35 #ifndef KERN_ppc32_CUDA_H_
    36 #define KERN_ppc32_CUDA_H_
     35#ifndef KERN_CUDA_H_
     36#define KERN_CUDA_H_
    3737
     38#include <ddi/irq.h>
    3839#include <arch/types.h>
    39 #include <typedefs.h>
     40#include <console/chardev.h>
    4041
    41 extern void cuda_init(uintptr_t base, size_t size);
    42 extern int cuda_get_scancode(void);
     42typedef struct {
     43} cuda_t;
     44
     45typedef struct {
     46        irq_t irq;
     47        cuda_t *cuda;
     48        indev_t *kbrdin;
     49} cuda_instance_t;
     50
     51extern cuda_instance_t *cuda_init(cuda_t *, inr_t, cir_t, void *);
     52extern void cuda_wire(cuda_instance_t *, indev_t *);
    4353
    4454#endif
  • kernel/genarch/include/drivers/z8530/z8530.h

    r44b7783 rc2417bc  
    117117        irq_t irq;
    118118        z8530_t *z8530;
    119         indev_t kbrdin;
     119        indev_t *kbrdin;
    120120} z8530_instance_t;
    121121
    122 extern indev_t *z8530_init(z8530_t *, inr_t, cir_t, void *);
     122extern z8530_instance_t *z8530_init(z8530_t *, inr_t, cir_t, void *);
     123extern void z8530_wire(z8530_instance_t *, indev_t *);
    123124
    124125#endif
  • kernel/genarch/include/kbrd/kbrd.h

    r44b7783 rc2417bc  
    3838
    3939#include <console/chardev.h>
     40#include <proc/thread.h>
     41#include <synch/spinlock.h>
    4042
    41 extern void kbrd_init(indev_t *devin);
     43typedef struct {
     44        thread_t *thread;
     45       
     46        indev_t *sink;
     47        indev_t raw;
     48       
     49        SPINLOCK_DECLARE(keylock);        /**< keylock protects keyflags and lockflags. */
     50        volatile unsigned int keyflags;   /**< Tracking of multiple keypresses. */
     51        volatile unsigned int lockflags;  /**< Tracking of multiple keys lockings. */
     52} kbrd_instance_t;
     53
     54extern kbrd_instance_t *kbrd_init(void);
     55extern indev_t *kbrd_wire(kbrd_instance_t *, indev_t *);
    4256
    4357#endif
  • kernel/genarch/include/srln/srln.h

    r44b7783 rc2417bc  
    3838
    3939#include <console/chardev.h>
     40#include <proc/thread.h>
    4041
    41 extern void srln_init(indev_t *devin);
     42typedef struct {
     43        thread_t *thread;
     44       
     45        indev_t *sink;
     46        indev_t raw;
     47} srln_instance_t;
     48
     49extern srln_instance_t *srln_init(void);
     50extern indev_t *srln_wire(srln_instance_t *, indev_t *);
    4251
    4352#endif
  • 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) 2005 Ondrej Palkovsky
     2 * Copyright (c) 2006 Martin Decky
    33 * All rights reserved.
    44 *
     
    2727 */
    2828
    29 /** @addtogroup mips32
     29/** @addtogroup genarch
    3030 * @{
    3131 */
     
    3333 */
    3434
    35 #include <console/console.h>
    36 #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>
    3741
    38 /** Acquire console back for kernel
    39  *
    40  */
    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  *
    50  */
    51 void arch_release_console(void)
     47static void cuda_irq_handler(irq_t *irq)
    5248{
    5349}
    5450
     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
    5577/** @}
    5678 */
  • 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
  • uspace/srv/kbd/port/sun.c

    r44b7783 rc2417bc  
    4040#include <sysinfo.h>
    4141
    42 typedef enum {
    43         KBD_UNKNOWN,
    44         KBD_Z8530,
    45         KBD_NS16550,
    46         KBD_SGCN
    47 } kbd_type_t;
    48 
    4942/** Sun keyboard virtual port driver.
    5043 *
     
    5750int kbd_port_init(void)
    5851{
    59         if (sysinfo_value("kbd.type") == KBD_Z8530)
    60                 return z8530_port_init();
    61         else if (sysinfo_value("kbd.type") == KBD_NS16550)
    62                 return ns16550_port_init();
     52        if (sysinfo_value("kbd.type.z8530")) {
     53                if (z8530_port_init() == 0)
     54                        return 0;
     55        }
     56       
     57        if (sysinfo_value("kbd.type.ns16550")) {
     58                if (ns16550_port_init() == 0)
     59                        return 0;
     60        }
    6361       
    6462        return -1;
Note: See TracChangeset for help on using the changeset viewer.