Changeset de57e060 in mainline


Ignore:
Timestamp:
2006-10-18T20:51:15Z (18 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
80ca47e
Parents:
cd13c2a
Message:

Convert ia64 to the new IRQ and notification scheme.

Files:
9 edited

Legend:

Unmodified
Added
Removed

  • kernel/arch/ia64/include/drivers/it.h

    rcd13c2a rde57e060  
    4545
    4646extern void it_init(void);
    47 extern void it_interrupt(void);
    4847
    4948#endif

  • kernel/arch/ia64/include/interrupt.h

    rcd13c2a rde57e060  
    4040#include <arch/register.h>
    4141
    42 #define IRQ_COUNT               257 /* 256 NOT suppotred IRQS*//* TODO */
    43 #define IRQ_KBD                 256 /* One simulated interrupt for ski simulator keyboard*/
     42/** ia64 has 256 INRs. */
     43#define INR_COUNT       256
     44
     45/*
     46 * We need to keep this just to compile.
     47 * We might eventually move interrupt/ stuff
     48 * to genarch.
     49 */
     50#define IVT_ITEMS       0
     51#define IVT_FIRST       0
    4452
    4553/** External Interrupt vectors. */
    … …  
    127135static inline int istate_from_uspace(istate_t *istate)
    128136{
    129         return (istate->cr_iip)<0xe000000000000000ULL;
     137        return (istate->cr_iip) < 0xe000000000000000ULL;
    130138}
    131139
    … …  
    137145extern void nop_handler(uint64_t vector, istate_t *istate);
    138146extern void external_interrupt(uint64_t vector, istate_t *istate);
    139 extern void virtual_interrupt(uint64_t irq, void *param);
    140147extern void disabled_fp_register(uint64_t vector, istate_t *istate);
    141148

  • kernel/arch/ia64/include/ski/ski.h

    rcd13c2a rde57e060  
    4343#define SKI_PUTCHAR             31
    4444
     45extern chardev_t ski_uconsole;
     46
    4547extern void ski_init_console(void);
    4648extern void ski_set_console_sysinfo(void);
    4749extern void poll_keyboard(void);
    4850
    49 extern chardev_t ski_uconsole;
    50 extern int kbd_uspace;
     51extern void ski_kbd_grab(void);
     52extern void ski_kbd_release(void);
    5153
    5254#endif

  • kernel/arch/ia64/src/drivers/it.c

    rcd13c2a rde57e060  
    4242#include <arch/barrier.h>
    4343#include <time/clock.h>
     44#include <ddi/irq.h>
     45#include <ddi/device.h>
    4446#include <arch.h>
    4547
     48#define IT_SERVICE_CLOCKS 64
    4649
    47 #define IT_SERVICE_CLOCKS 64
     50static irq_t it_irq;
     51
     52static irq_ownership_t it_claim(void);
     53static void it_interrupt(irq_t *irq, void *arg, ...);
    4854
    4955/** Initialize Interval Timer. */
    … …  
    5157{
    5258        cr_itv_t itv;
     59
     60        irq_initialize(&it_irq);
     61        it_irq.inr = INTERRUPT_TIMER;
     62        it_irq.devno = device_assign_devno();
     63        it_irq.claim = it_claim;
     64        it_irq.handler = it_interrupt;
     65        irq_register(&it_irq);
    5366
    5467        /* initialize Interval Timer external interrupt vector */
    … …  
    6881}
    6982
     83/** Always claim ownership for this IRQ.
     84 *
     85 * Other devices are responsible to avoid using INR 0.
     86 *
     87 * @return Always IRQ_ACCEPT.
     88 */
     89irq_ownership_t it_claim(void)
     90{
     91        return IRQ_ACCEPT;
     92}
    7093
    7194/** Process Interval Timer interrupt. */
    72 void it_interrupt(void)
     95void it_interrupt(irq_t *irq, void *arg, ...)
    7396{
    7497        int64_t c;
    … …  
    84107
    85108                m += IT_DELTA;
    86                 if (m-c<0)
     109                if (m - c < 0)
    87110                        CPU->missed_clock_ticks++;
    88111                else
    … …  
    94117       
    95118        clock();
     119       
     120        /*
     121         * This one is a good candidate for moving to a separate
     122         * kernel thread private to ski.c
     123         */
    96124        poll_keyboard();
    97125}

  • kernel/arch/ia64/src/ia64.c

    rcd13c2a rde57e060  
    5050#include <proc/uarg.h>
    5151#include <syscall/syscall.h>
    52 
    53 static int kbd_release=0;
     52#include <ddi/irq.h>
    5453
    5554void arch_pre_main(void)
    … …  
    8180        srlz_d();
    8281       
    83         ski_init_console();
    84         it_init();     
    8582}
    8683
    8784void arch_post_mm_init(void)
    8885{
     86        irq_init(INR_COUNT, INR_COUNT);
     87        ski_init_console();
     88        it_init();     
    8989        ski_set_console_sysinfo();
    9090}
    … …  
    146146void arch_grab_console(void)
    147147{
    148     kbd_release=kbd_uspace;
    149     kbd_uspace=0;
     148        ski_kbd_grab();
    150149}
    151150/** Return console to userspace
    … …  
    154153void arch_release_console(void)
    155154{
    156     kbd_uspace=kbd_release;
     155        ski_kbd_release();
    157156}
    158157

  • kernel/arch/ia64/src/interrupt.c

    rcd13c2a rde57e060  
    3535
    3636#include <arch/interrupt.h>
     37#include <interrupt.h>
     38#include <ddi/irq.h>
    3739#include <panic.h>
    3840#include <print.h>
     41#include <symtab.h>
     42#include <debug.h>
    3943#include <console/console.h>
    4044#include <arch/types.h>
    … …  
    4246#include <arch/barrier.h>
    4347#include <arch/register.h>
    44 #include <arch/drivers/it.h>
    4548#include <arch.h>
    46 #include <symtab.h>
    47 #include <debug.h>
    4849#include <syscall/syscall.h>
    4950#include <print.h>
    … …  
    5253#include <ipc/irq.h>
    5354#include <ipc/ipc.h>
    54 #include <interrupt.h>
    55 
     55#include <synch/spinlock.h>
    5656
    5757#define VECTORS_64_BUNDLE       20
    … …  
    6161
    6262#define BUNDLE_SIZE             16
    63 
    6463
    6564char *vector_names_64_bundle[VECTORS_64_BUNDLE] = {
    … …  
    198197}
    199198
    200 
    201199void nop_handler(uint64_t vector, istate_t *istate)
    202200{
    203201}
    204 
    205202
    206203/** Handle syscall. */
    … …  
    229226void external_interrupt(uint64_t vector, istate_t *istate)
    230227{
     228        irq_t *irq;
    231229        cr_ivr_t ivr;
    232230       
    … …  
    234232        srlz_d();
    235233
    236         switch(ivr.vector) {
    237         case INTERRUPT_TIMER:
    238                 it_interrupt();
    239                 break;
    240         case INTERRUPT_SPURIOUS:
    241                 printf("cpu%d: spurious interrupt\n", CPU->id);
    242                 break;
    243         default:
    244                 panic("\nUnhandled External Interrupt Vector %d\n", ivr.vector);
    245                 break;
     234        irq = irq_dispatch_and_lock(ivr.vector);
     235        if (irq) {
     236                irq->handler(irq, irq->arg);
     237                spinlock_unlock(&irq->lock);
     238        } else {
     239                switch (ivr.vector) {
     240                case INTERRUPT_SPURIOUS:
     241#ifdef CONFIG_DEBUG
     242                        printf("cpu%d: spurious interrupt\n", CPU->id);
     243#endif
     244                        break;
     245
     246                default:
     247                        panic("\nUnhandled External Interrupt Vector %d\n", ivr.vector);
     248                        break;
     249                }
    246250        }
    247251}
    248252
    249 void virtual_interrupt(uint64_t irq, void *param)
    250 {
    251         switch(irq) {
    252         case IRQ_KBD:
    253                 if (kbd_uspace)
    254                         ipc_irq_send_notif(irq);
    255                 break;
    256         default:
    257                 panic("\nUnhandled Virtual Interrupt request %d\n", irq);
    258                 break;
    259         }
    260 }
    261 
    262253/** @}
    263254 */

  • kernel/arch/ia64/src/ski/ski.c

    rcd13c2a rde57e060  
    3838#include <arch/interrupt.h>
    3939#include <sysinfo/sysinfo.h>
     40#include <arch/types.h>
     41#include <typedefs.h>
     42#include <ddi/device.h>
     43#include <ddi/irq.h>
     44#include <ipc/irq.h>
     45#include <synch/spinlock.h>
     46#include <arch/asm.h>
     47
     48#define SKI_KBD_INR     0
     49
     50static irq_t ski_kbd_irq;
     51static devno_t ski_kbd_devno;
    4052
    4153chardev_t ski_console;
    4254chardev_t ski_uconsole;
    43 static bool kb_disable;
    44 int kbd_uspace=0;
     55
     56static bool kbd_disabled;
    4557
    4658static void ski_putchar(chardev_t *d, const char ch);
    … …  
    5870{
    5971        __asm__ volatile (
    60                 "mov r15=%0\n"
    61                 "mov r32=%1\n"          /* r32 is in0 */
     72                "mov r15 = %0\n"
     73                "mov r32 = %1\n"        /* r32 is in0 */
    6274                "break 0x80000\n"       /* modifies r8 */
    6375                :
    … …  
    8496       
    8597        __asm__ volatile (
    86                 "mov r15=%1\n"
     98                "mov r15 = %1\n"
    8799                "break 0x80000;;\n"     /* modifies r8 */
    88                 "mov %0=r8;;\n"         
     100                "mov %0 = r8;;\n"               
    89101
    90102                : "=r" (ch)
    91103                : "i" (SKI_GETCHAR)
    92                 : "r15",  "r8"
     104                : "r15", "r8"
    93105        );
    94106
    … …  
    104116        int ch;
    105117
    106         while(!(ch=ski_getchar()))
     118        while(!(ch = ski_getchar()))
    107119                ;
    108120        if(ch == '\r')
    … …  
    116128        char ch;
    117129        static char last;
    118 
    119         if (kb_disable)
     130        ipl_t ipl;
     131
     132        ipl = interrupts_disable();
     133
     134        if (kbd_disabled) {
     135                interrupts_restore(ipl);
    120136                return;
     137        }
     138               
     139        spinlock_lock(&ski_kbd_irq.lock);
    121140
    122141        ch = ski_getchar();
    123142        if(ch == '\r')
    124143                ch = '\n';
    125         if (ch){
    126                 if(kbd_uspace){
     144        if (ch) {
     145                if (ski_kbd_irq.notif_cfg.notify && ski_kbd_irq.notif_cfg.answerbox) {
    127146                        chardev_push_character(&ski_uconsole, ch);
    128                         virtual_interrupt(IRQ_KBD,NULL);
    129                 }
    130                 else {
     147                        ipc_irq_send_notif(&ski_kbd_irq);
     148                } else {
    131149                        chardev_push_character(&ski_console, ch);
    132150                }       
    133                 last = ch;             
     151                last = ch;
     152                spinlock_unlock(&ski_kbd_irq.lock);
     153                interrupts_restore(ipl);
    134154                return;
    135         }       
    136 
    137         if (last){
    138                 if(kbd_uspace){
     155        }
     156
     157        if (last) {
     158                if (ski_kbd_irq.notif_cfg.notify && ski_kbd_irq.notif_cfg.answerbox) {
    139159                        chardev_push_character(&ski_uconsole, 0);
    140                         virtual_interrupt(IRQ_KBD,NULL);
     160                        ipc_irq_send_notif(&ski_kbd_irq);
    141161                }
    142                 else {
    143                 }       
    144                 last = 0;               
    145         }       
    146 
     162                last = 0;
     163        }
     164
     165        spinlock_unlock(&ski_kbd_irq.lock);
     166        interrupts_restore(ipl);
    147167}
    148168
    149169/* Called from getc(). */
    150 static void ski_kb_enable(chardev_t *d)
    151 {
    152         kb_disable = false;
     170static void ski_kbd_enable(chardev_t *d)
     171{
     172        kbd_disabled = false;
    153173}
    154174
    155175/* Called from getc(). */
    156 static void ski_kb_disable(chardev_t *d)
    157 {
    158         kb_disable = true;     
     176static void ski_kbd_disable(chardev_t *d)
     177{
     178        kbd_disabled = true;   
     179}
     180
     181/** Decline to service hardware IRQ.
     182 *
     183 * This is only a virtual IRQ, so always decline.
     184 *
     185 * @return Always IRQ_DECLINE.
     186 */
     187static irq_ownership_t ski_kbd_claim(void)
     188{
     189        return IRQ_DECLINE;
    159190}
    160191
    161192static chardev_operations_t ski_ops = {
    162         .resume = ski_kb_enable,
    163         .suspend = ski_kb_disable,
     193        .resume = ski_kbd_enable,
     194        .suspend = ski_kbd_disable,
    164195        .write = ski_putchar,
    165196        .read = ski_getchar_blocking
    … …  
    174205{
    175206        __asm__ volatile (
    176                 "mov r15=%0\n"
     207                "mov r15 = %0\n"
    177208                "break 0x80000\n"
    178209                :
    … …  
    186217        stdout = &ski_console;
    187218
     219        ski_kbd_devno = device_assign_devno();
     220       
     221        irq_initialize(&ski_kbd_irq);
     222        ski_kbd_irq.inr = SKI_KBD_INR;
     223        ski_kbd_irq.devno = ski_kbd_devno;
     224        ski_kbd_irq.claim = ski_kbd_claim;
     225        irq_register(&ski_kbd_irq);
     226
    188227}
    189228
    … …  
    196235void ski_set_console_sysinfo(void)
    197236{
    198         sysinfo_set_item_val("kbd",NULL,true);
    199         sysinfo_set_item_val("kbd.irq",NULL,IRQ_KBD);
     237        sysinfo_set_item_val("kbd", NULL, true);
     238        sysinfo_set_item_val("kbd.inr", NULL, SKI_KBD_INR);
     239        sysinfo_set_item_val("kbd.devno", NULL, ski_kbd_devno);
     240}
     241
     242void ski_kbd_grab(void)
     243{
     244        ski_kbd_irq.notif_cfg.notify = false;
     245}
     246
     247void ski_kbd_release(void)
     248{
     249        if (ski_kbd_irq.notif_cfg.answerbox)
     250                ski_kbd_irq.notif_cfg.notify = true;
    200251}
    201252

  • kernel/arch/sparc64/include/interrupt.h

    rcd13c2a rde57e060  
    4141#include <arch/regdef.h>
    4242
    43 #define IRQ_COUNT       1                       /* TODO */
    44 
    4543#define IVT_ITEMS       15
    4644#define IVT_FIRST       1

  • uspace/kbd/arch/ia64/src/kbd.c

    rcd13c2a rde57e060  
    6868{
    6969        if (sysinfo_value("kbd")) {
    70                 ipc_register_irq(sysinfo_value("kbd.irq"), &ski_kbd);
     70                ipc_register_irq(sysinfo_value("kbd.inr"), sysinfo_value("kbd.devno"), 0, &ski_kbd);
    7171                return 0;
    7272        }       
    … …  
    8585int kbd_arch_process(keybuffer_t *keybuffer, ipc_call_t *call)
    8686{
    87         static unsigned long long buf=0;
    88         static int count=0;     
    89         static int esc_count=0;
     87        static unsigned long long buf = 0;
     88        static int count = 0;   
     89        static int esc_count = 0;
    9090        int scan_code = IPC_GET_ARG2(*call);
    9191
Note: See TracChangeset for help on using the changeset viewer.