Changeset 3e828ea in mainline for kernel/arch/ia32/src


Ignore:
Timestamp:
2019-09-23T12:49:29Z (7 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
9be2358
Parents:
9259d20 (diff), 1a4ec93f (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
git-author:
Jiri Svoboda <jiri@…> (2019-09-22 12:49:07)
git-committer:
Jiri Svoboda <jiri@…> (2019-09-23 12:49:29)
Message:

Merge changes from master, especially Meson build

Location:
kernel/arch/ia32/src
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • kernel/arch/ia32/src/debug/stacktrace.c

    r9259d20 r3e828ea  
    6767bool uspace_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
    6868{
    69         return !copy_from_uspace((void *) prev,
    70             (uint32_t *) ctx->fp + FRAME_OFFSET_FP_PREV, sizeof(*prev));
     69        return !copy_from_uspace(prev,
     70            ctx->fp + sizeof(uintptr_t) * FRAME_OFFSET_FP_PREV, sizeof(*prev));
    7171}
    7272
    7373bool uspace_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
    7474{
    75         return !copy_from_uspace((void *) ra,
    76             (uint32_t *) ctx->fp + FRAME_OFFSET_RA, sizeof(*ra));
     75        return !copy_from_uspace(ra,
     76            ctx->fp + sizeof(uintptr_t) * FRAME_OFFSET_RA, sizeof(*ra));
    7777}
    7878

  • kernel/arch/ia32/src/drivers/i8254.c

    r9259d20 r3e828ea  
    9696{
    9797        pio_write_8(CLK_PORT4, 0x36);
    98         pic_disable_irqs(1 << IRQ_CLK);
     98        i8259_disable_irqs(1 << IRQ_CLK);
    9999        pio_write_8(CLK_PORT1, (CLK_CONST / HZ) & 0xf);
    100100        pio_write_8(CLK_PORT1, (CLK_CONST / HZ) >> 8);
    101         pic_enable_irqs(1 << IRQ_CLK);
     101        i8259_enable_irqs(1 << IRQ_CLK);
    102102}
    103103
    … …  
    143143        o2 |= pio_read_8(CLK_PORT1) << 8;
    144144
     145        uint32_t delta = (t1 - t2) - (o1 - o2);
     146        if (!delta)
     147                delta = 1;
     148
    145149        CPU->delay_loop_const =
    146             ((MAGIC_NUMBER * LOOPS) / 1000) / ((t1 - t2) - (o1 - o2)) +
    147             (((MAGIC_NUMBER * LOOPS) / 1000) % ((t1 - t2) - (o1 - o2)) ? 1 : 0);
     150            ((MAGIC_NUMBER * LOOPS) / 1000) / delta +
     151            (((MAGIC_NUMBER * LOOPS) / 1000) % delta ? 1 : 0);
    148152
    149153        uint64_t clk1 = get_cycle();

  • kernel/arch/ia32/src/ia32.c

    r9259d20 r3e828ea  
    5858#include <genarch/multiboot/multiboot.h>
    5959#include <genarch/multiboot/multiboot2.h>
     60#include <genarch/pic/pic_ops.h>
    6061#include <arch/pm.h>
    6162#include <arch/vreg.h>
    … …  
    110111                /* PIC */
    111112                i8259_init((i8259_t *) I8259_PIC0_BASE,
    112                     (i8259_t *) I8259_PIC1_BASE, IRQ_PIC1, IVT_IRQBASE,
    113                     IVT_IRQBASE + 8);
    114 
    115                 /*
    116                  * Set the enable/disable IRQs handlers.
    117                  * Set the End-of-Interrupt handler.
    118                  */
    119                 enable_irqs_function = pic_enable_irqs;
    120                 disable_irqs_function = pic_disable_irqs;
    121                 eoi_function = pic_eoi;
    122                 irqs_info = "i8259";
     113                    (i8259_t *) I8259_PIC1_BASE, IVT_IRQBASE);
     114
     115                /* Set PIC operations. */
     116                pic_ops = &i8259_pic_ops;
    123117        }
    124118}
    … …  
    195189                        indev_t *kbrd = kbrd_wire(kbrd_instance, sink);
    196190                        i8042_wire(i8042_instance, kbrd);
    197                         trap_virtual_enable_irqs(1 << IRQ_KBD);
    198                         trap_virtual_enable_irqs(1 << IRQ_MOUSE);
     191                        pic_ops->enable_irqs(1 << IRQ_KBD);
     192                        pic_ops->enable_irqs(1 << IRQ_MOUSE);
    199193                }
    200194        }
    … …  
    221215                        indev_t *srln = srln_wire(srln_instance, sink);
    222216                        ns16550_wire(ns16550_instance, srln);
    223                         trap_virtual_enable_irqs(1 << IRQ_NS16550);
     217                        pic_ops->enable_irqs(1 << IRQ_NS16550);
    224218                }
    225219#endif
    … …  
    232226#endif
    233227
    234         if (irqs_info != NULL)
    235                 sysinfo_set_item_val(irqs_info, NULL, true);
     228        sysinfo_set_item_val(pic_ops->get_name(), NULL, true);
    236229}
    237230

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

    r9259d20 r3e828ea  
    4040#include <panic.h>
    4141#include <genarch/drivers/i8259/i8259.h>
     42#include <genarch/pic/pic_ops.h>
    4243#include <halt.h>
    4344#include <cpu.h>
    … …  
    6162 */
    6263
    63 void (*disable_irqs_function)(uint16_t irqmask) = NULL;
    64 void (*enable_irqs_function)(uint16_t irqmask) = NULL;
    65 void (*eoi_function)(void) = NULL;
    66 const char *irqs_info = NULL;
     64pic_ops_t *pic_ops = NULL;
    6765
    6866void istate_decode(istate_t *istate)
    … …  
    8886            istate_from_uspace(istate) ? istate->esp :
    8987            (uint32_t) &istate->esp);
    90 }
    91 
    92 static void trap_virtual_eoi(void)
    93 {
    94         if (eoi_function)
    95                 eoi_function();
    96         else
    97                 panic("No eoi_function.");
    98 
    9988}
    10089
    … …  
    179168    istate_t *istate __attribute__((unused)))
    180169{
    181         trap_virtual_eoi();
     170        pic_ops->eoi(0);
    182171        tlb_shootdown_ipi_recv();
    183172}
    … …  
    192181        bool ack = false;
    193182        assert(inum < IRQ_COUNT);
    194         assert((inum != IRQ_PIC_SPUR) && (inum != IRQ_PIC1));
     183        assert(inum != IRQ_PIC1);
    195184
    196185        irq_t *irq = irq_dispatch_and_lock(inum);
    … …  
    202191                if (irq->preack) {
    203192                        /* Send EOI before processing the interrupt */
    204                         trap_virtual_eoi();
     193                        pic_ops->eoi(inum);
    205194                        ack = true;
    206195                }
    … …  
    208197                irq_spinlock_unlock(&irq->lock, false);
    209198        } else {
    210                 /*
    211                  * Spurious interrupt.
    212                  */
    213199#ifdef CONFIG_DEBUG
    214                 printf("cpu%u: spurious interrupt (inum=%u)\n", CPU->id, inum);
     200                log(LF_ARCH, LVL_DEBUG, "cpu%u: unhandled IRQ %u", CPU->id,
     201                    inum);
    215202#endif
    216203        }
    217204
    218205        if (!ack)
    219                 trap_virtual_eoi();
     206                pic_ops->eoi(inum);
     207}
     208
     209static void pic_spurious(unsigned int n, istate_t *istate)
     210{
     211        unsigned int inum = n - IVT_IRQBASE;
     212        if (!pic_ops->is_spurious(inum)) {
     213                /* This is actually not a spurious IRQ, so proceed as usual. */
     214                irq_interrupt(n, istate);
     215                return;
     216        }
     217        pic_ops->handle_spurious(n);
     218#ifdef CONFIG_DEBUG
     219        log(LF_ARCH, LVL_DEBUG, "cpu%u: PIC spurious interrupt %u", CPU->id,
     220            inum);
     221#endif
    220222}
    221223
    … …  
    228230
    229231        for (i = 0; i < IRQ_COUNT; i++) {
    230                 if ((i != IRQ_PIC_SPUR) && (i != IRQ_PIC1))
     232                if ((i != IRQ_PIC0_SPUR) && (i != IRQ_PIC1_SPUR) &&
     233                    (i != IRQ_PIC1))
    231234                        exc_register(IVT_IRQBASE + i, "irq", true,
    232235                            (iroutine_t) irq_interrupt);
    … …  
    239242        exc_register(VECTOR_GP, "gp_fault", true, (iroutine_t) gp_fault);
    240243        exc_register(VECTOR_XM, "simd_fp", true, (iroutine_t) simd_fp_exception);
     244        exc_register(VECTOR_PIC0_SPUR, "pic0_spurious", true,
     245            (iroutine_t) pic_spurious);
     246        exc_register(VECTOR_PIC1_SPUR, "pic1_spurious", true,
     247            (iroutine_t) pic_spurious);
    241248
    242249#ifdef CONFIG_SMP
    … …  
    246253}
    247254
    248 void trap_virtual_enable_irqs(uint16_t irqmask)
    249 {
    250         if (enable_irqs_function)
    251                 enable_irqs_function(irqmask);
    252         else
    253                 panic("No enable_irqs_function.");
    254 }
    255 
    256 void trap_virtual_disable_irqs(uint16_t irqmask)
    257 {
    258         if (disable_irqs_function)
    259                 disable_irqs_function(irqmask);
    260         else
    261                 panic("No disable_irqs_function.");
    262 }
    263 
    264255/** @}
    265256 */

  • kernel/arch/ia32/src/smp/apic.c

    r9259d20 r3e828ea  
    4747#include <arch.h>
    4848#include <ddi/irq.h>
     49#include <genarch/pic/pic_ops.h>
    4950
    5051#ifdef CONFIG_SMP
    … …  
    6364 */
    6465
     66static const char *apic_get_name(void);
     67static bool l_apic_is_spurious(unsigned int);
     68static void l_apic_handle_spurious(unsigned int);
     69
     70pic_ops_t apic_pic_ops = {
     71        .get_name = apic_get_name,
     72        .enable_irqs = io_apic_enable_irqs,
     73        .disable_irqs = io_apic_disable_irqs,
     74        .eoi = l_apic_eoi,
     75        .is_spurious = l_apic_is_spurious,
     76        .handle_spurious = l_apic_handle_spurious,
     77};
     78
    6579/*
    6680 * These variables either stay configured as initilalized, or are changed by
    … …  
    125139#endif /* LAPIC_VERBOSE */
    126140
     141const char *apic_get_name(void)
     142{
     143        return "apic";
     144}
     145
     146bool l_apic_is_spurious(unsigned int n)
     147{
     148        return n == VECTOR_APIC_SPUR;
     149}
     150
     151void l_apic_handle_spurious(unsigned int n)
     152{
     153}
     154
    127155/** APIC spurious interrupt handler.
    128156 *
    … …  
    134162    istate_t *istate __attribute__((unused)))
    135163{
    136 #ifdef CONFIG_DEBUG
    137         log(LF_ARCH, LVL_DEBUG, "cpu%u: APIC spurious interrupt", CPU->id);
    138 #endif
    139164}
    140165
    … …  
    175200            (iroutine_t) apic_spurious);
    176201
    177         enable_irqs_function = io_apic_enable_irqs;
    178         disable_irqs_function = io_apic_disable_irqs;
    179         eoi_function = l_apic_eoi;
    180         irqs_info = "apic";
     202        pic_ops = &apic_pic_ops;
    181203
    182204        /*
    … …  
    508530
    509531/** Local APIC End of Interrupt. */
    510 void l_apic_eoi(void)
     532void l_apic_eoi(unsigned int ignored)
    511533{
    512534        l_apic[EOI] = 0;

  • kernel/arch/ia32/src/smp/smp.c

    r9259d20 r3e828ea  
    130130        pio_write_8((ioport8_t *) 0x71, 0xa);
    131131
    132         pic_disable_irqs(0xffff);
     132        i8259_disable_irqs(0xffff);
    133133        apic_init();
    134134

  • kernel/arch/ia32/src/userspace.c

    r9259d20 r3e828ea  
    7070            : [eflags_mask] "i" (~EFLAGS_NT),
    7171              [udata_des] "i" (GDT_SELECTOR(UDATA_DES) | PL_USER),
    72               [stack_top] "r" ((uint8_t *) kernel_uarg->uspace_stack +
     72              [stack_top] "r" (kernel_uarg->uspace_stack +
    7373              kernel_uarg->uspace_stack_size),
    7474              [eflags] "r" ((eflags & ~(EFLAGS_NT)) | EFLAGS_IF),
Note: See TracChangeset for help on using the changeset viewer.