Changeset 3e828ea in mainline for kernel/genarch/src

Timestamp:

2019-09-23T12:49:29Z (6 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/genarch/src

Files:

• drivers/gicv2/gicv2.c (added)
• drivers/i8259/i8259.c (modified) (7 diffs)
• drivers/ns16550/ns16550.c (modified) (5 diffs)
• drivers/pl011/pl011.c (modified) (3 diffs)
• mm/as_pt.c (modified) (2 diffs)
• multiboot/multiboot2.c (modified) (1 diff)

kernel/genarch/src/drivers/i8259/i8259.c

@@ -32 +32 @@
 /**
  * @file
- * @brief PIC driver.
+ * @brief i8259 driver.
  *
  * Programmable Interrupt Controller for UP systems based on i8259 chip.
@@ -43 +43 @@
 #include <interrupt.h>
 
-static void pic_spurious(unsigned int n, istate_t *istate);
+/* ICW1 bits */
+#define I8259_ICW1           (1 << 4)
+#define I8259_ICW1_NEEDICW4  (1 << 0)
+
+/* OCW3 bits */
+#define I8259_OCW3           (1 << 3)
+#define I8259_OCW3_READ_ISR  (3 << 0)
+
+/* OCW4 bits */
+#define I8259_OCW4           (0 << 3)
+#define I8259_OCW4_NSEOI     (1 << 5)
+
+#define I8259_IRQ_COUNT 8
+
+#define I8259_IRQ_SLAVE 2
+
+static const char *i8259_get_name(void);
+
+pic_ops_t i8259_pic_ops = {
+        .get_name = i8259_get_name,
+        .enable_irqs = i8259_enable_irqs,
+        .disable_irqs = i8259_disable_irqs,
+        .eoi = i8259_eoi,
+        .is_spurious = i8259_is_spurious,
+        .handle_spurious = i8259_handle_spurious
+};
 
 // XXX: need to change pic_* API to get rid of these
@@ -49 +74 @@
 static i8259_t *saved_pic1;
 
-void i8259_init(i8259_t *pic0, i8259_t *pic1, inr_t pic1_irq,
-    unsigned int irq0_int, unsigned int irq8_int)
+void i8259_init(i8259_t *pic0, i8259_t *pic1, unsigned int irq0_vec)
 {
         saved_pic0 = pic0;
@@ -56 +80 @@
 
         /* ICW1: this is ICW1, ICW4 to follow */
-        pio_write_8(&pic0->port1, PIC_ICW1 | PIC_ICW1_NEEDICW4);
+        pio_write_8(&pic0->port1, I8259_ICW1 | I8259_ICW1_NEEDICW4);
 
-        /* ICW2: IRQ 0 maps to INT irq0_int */
-        pio_write_8(&pic0->port2, irq0_int);
+        /* ICW2: IRQ 0 maps to interrupt vector address irq0_vec */
+        pio_write_8(&pic0->port2, irq0_vec);
 
-        /* ICW3: pic1 using IRQ IRQ_PIC1 */
-        pio_write_8(&pic0->port2, 1 << pic1_irq);
+        /* ICW3: pic1 using IRQ I8259_IRQ_SLAVE */
+        pio_write_8(&pic0->port2, 1 << I8259_IRQ_SLAVE);
 
         /* ICW4: i8086 mode */
@@ -68 +92 @@
 
         /* ICW1: ICW1, ICW4 to follow */
-        pio_write_8(&pic1->port1, PIC_ICW1 | PIC_ICW1_NEEDICW4);
+        pio_write_8(&pic1->port1, I8259_ICW1 | I8259_ICW1_NEEDICW4);
 
-        /* ICW2: IRQ 8 maps to INT irq8_int */
-        pio_write_8(&pic1->port2, irq8_int);
+        /* ICW2: IRQ 8 maps to interrupt vector address irq0_vec + 8 */
+        pio_write_8(&pic1->port2, irq0_vec + I8259_IRQ_COUNT);
 
-        /* ICW3: pic1 is known as IRQ_PIC1 */
-        pio_write_8(&pic1->port2, pic1_irq);
+        /* ICW3: pic1 is known as I8259_IRQ_SLAVE */
+        pio_write_8(&pic1->port2, I8259_IRQ_SLAVE);
 
         /* ICW4: i8086 mode */
         pio_write_8(&pic1->port2, 1);
 
-        /*
-         * Register interrupt handler for the PIC spurious interrupt.
-         *
-         * XXX: This is currently broken. Both IRQ 7 and IRQ 15 can be spurious
-         *      or can be actual interrupts. This needs to be detected when
-         *      the interrupt happens by inspecting ISR.
-         */
-        exc_register(irq0_int + 7, "pic_spurious", false,
-            (iroutine_t) pic_spurious);
-
-        pic_disable_irqs(0xffff);               /* disable all irq's */
-        pic_enable_irqs(1 << pic1_irq);         /* but enable pic1_irq */
+        /* disable all irq's */
+        i8259_disable_irqs(0xffff);
+        /* but enable I8259_IRQ_SLAVE */
+        i8259_enable_irqs(1 << I8259_IRQ_SLAVE);
 }
 
-void pic_enable_irqs(uint16_t irqmask)
+const char *i8259_get_name(void)
+{
+        return "i8259";
+}
+
+void i8259_enable_irqs(uint16_t irqmask)
 {
         uint8_t x;
@@ -102 +123 @@
                     (uint8_t) (x & (~(irqmask & 0xff))));
         }
-        if (irqmask >> 8) {
+        if (irqmask >> I8259_IRQ_COUNT) {
                 x = pio_read_8(&saved_pic1->port2);
                 pio_write_8(&saved_pic1->port2,
-                    (uint8_t) (x & (~(irqmask >> 8))));
+                    (uint8_t) (x & (~(irqmask >> I8259_IRQ_COUNT))));
         }
 }
 
-void pic_disable_irqs(uint16_t irqmask)
+void i8259_disable_irqs(uint16_t irqmask)
 {
         uint8_t x;
@@ -118 +139 @@
                     (uint8_t) (x | (irqmask & 0xff)));
         }
-        if (irqmask >> 8) {
+        if (irqmask >> I8259_IRQ_COUNT) {
                 x = pio_read_8(&saved_pic1->port2);
-                pio_write_8(&saved_pic1->port2, (uint8_t) (x | (irqmask >> 8)));
+                pio_write_8(&saved_pic1->port2,
+                    (uint8_t) (x | (irqmask >> I8259_IRQ_COUNT)));
         }
 }
 
-void pic_eoi(void)
+void i8259_eoi(unsigned int irq)
 {
-        pio_write_8(&saved_pic0->port1, PIC_OCW4 | PIC_OCW4_NSEOI);
-        pio_write_8(&saved_pic1->port1, PIC_OCW4 | PIC_OCW4_NSEOI);
+        if (irq >= I8259_IRQ_COUNT)
+                pio_write_8(&saved_pic1->port1, I8259_OCW4 | I8259_OCW4_NSEOI);
+        pio_write_8(&saved_pic0->port1, I8259_OCW4 | I8259_OCW4_NSEOI);
 }
 
-void pic_spurious(unsigned int n __attribute__((unused)), istate_t *istate __attribute__((unused)))
+bool i8259_is_spurious(unsigned int irq)
 {
-#ifdef CONFIG_DEBUG
-        log(LF_ARCH, LVL_DEBUG, "cpu%u: PIC spurious interrupt", CPU->id);
-#endif
+        pio_write_8(&saved_pic0->port1, I8259_OCW3 | I8259_OCW3_READ_ISR);
+        pio_write_8(&saved_pic1->port1, I8259_OCW3 | I8259_OCW3_READ_ISR);
+        uint8_t isr_lo = pio_read_8(&saved_pic0->port1);
+        uint8_t isr_hi = pio_read_8(&saved_pic1->port1);
+        return !(((isr_hi << I8259_IRQ_COUNT) | isr_lo) & (1 << irq));
+}
+
+void i8259_handle_spurious(unsigned int irq)
+{
+        /* For spurious IRQs from pic1, we need to isssue an EOI to pic0 */
+        if (irq >= I8259_IRQ_COUNT)
+                pio_write_8(&saved_pic0->port1, I8259_OCW4 | I8259_OCW4_NSEOI);
 }
 

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

@@ -39 +39 @@
 #include <genarch/drivers/ns16550/ns16550.h>
 #include <ddi/irq.h>
+#include <ddi/ddi.h>
 #include <arch/asm.h>
 #include <console/chardev.h>
 #include <stdlib.h>
+#include <align.h>
 #include <str.h>
 
@@ -115 +117 @@
 
         if ((!instance->parea.mapped) || (console_override)) {
+                if (ch == '\n')
+                        ns16550_sendb(instance, '\r');
+
                 if (ascii_check(ch))
                         ns16550_sendb(instance, (uint8_t) ch);
@@ -143 +148 @@
  *
  */
-ns16550_instance_t *ns16550_init(ioport8_t *dev, unsigned reg_shift, inr_t inr,
-    cir_t cir, void *cir_arg, outdev_t **output)
-{
-        ns16550_instance_t *instance =
-            malloc(sizeof(ns16550_instance_t));
+ns16550_instance_t *ns16550_init(ioport8_t *dev_phys, unsigned reg_shift,
+    inr_t inr, cir_t cir, void *cir_arg, outdev_t **output)
+{
+        size_t size = 6 * (1U << reg_shift);
+        ioport8_t *dev = pio_map((void *) dev_phys, size);
+
+        ns16550_instance_t *instance = malloc(sizeof(ns16550_instance_t));
         if (instance) {
                 instance->ns16550 = dev;
@@ -158 +165 @@
                         if (!instance->output) {
                                 free(instance);
+                                pio_unmap((void *) dev_phys, (void *) dev,
+                                    size);
                                 return NULL;
                         }
@@ -176 +185 @@
 
                 ddi_parea_init(&instance->parea);
-                instance->parea.pbase = (uintptr_t) dev;
-                instance->parea.frames = 1;
+                instance->parea.pbase = ALIGN_DOWN((uintptr_t) dev_phys,
+                    PAGE_SIZE);
+                instance->parea.frames = ALIGN_UP(size, PAGE_SIZE);
                 instance->parea.unpriv = false;
                 instance->parea.mapped = false;

kernel/genarch/src/drivers/pl011/pl011.c

@@ -60 +60 @@
         pl011_uart_t *uart = dev->data;
 
-        if (!ascii_check(ch)) {
+        /* If the userspace owns the console, do not output anything. */
+        if (uart->parea.mapped && !console_override)
+                return;
+
+        if (!ascii_check(ch))
                 pl011_uart_sendb(uart, U_SPECIAL);
-        } else {
+        else {
                 if (ch == '\n')
                         pl011_uart_sendb(uart, (uint8_t) '\r');
@@ -100 +104 @@
         assert(uart);
         uart->regs = (void *)km_map(addr, sizeof(pl011_uart_regs_t),
-            KM_NATURAL_ALIGNMENT, PAGE_NOT_CACHEABLE);
+            KM_NATURAL_ALIGNMENT, PAGE_WRITE | PAGE_NOT_CACHEABLE);
         assert(uart->regs);
 
@@ -131 +135 @@
         uart->irq.instance = uart;
 
+        ddi_parea_init(&uart->parea);
+        uart->parea.pbase = addr;
+        uart->parea.frames = 1;
+        uart->parea.unpriv = false;
+        uart->parea.mapped = false;
+        ddi_parea_register(&uart->parea);
+
         return true;
 }

kernel/genarch/src/mm/as_pt.c

@@ -76 +76 @@
             PA2KA(frame_alloc(PTL0_FRAMES, FRAME_LOWMEM, PTL0_SIZE - 1));
 
-        if (flags & FLAG_AS_KERNEL)
-                memsetb(dst_ptl0, PTL0_SIZE, 0);
-        else {
+        memsetb(dst_ptl0, PTL0_SIZE, 0);
+
+        if (!KERNEL_SEPARATE_PTL0 && !(flags & FLAG_AS_KERNEL)) {
                 /*
                  * Copy the kernel address space portion to new PTL0.
@@ -93 +93 @@
                     &dst_ptl0[PTL0_INDEX(KERNEL_ADDRESS_SPACE_START)];
 
-                memsetb(dst_ptl0, PTL0_SIZE, 0);
                 memcpy((void *) dst, (void *) src,
                     PTL0_SIZE - (src - (uintptr_t) src_ptl0));

kernel/genarch/src/multiboot/multiboot2.c

@@ -65 +65 @@
         multiboot2_memmap_entry_t *entry = (multiboot2_memmap_entry_t *)
             ((uintptr_t) memmap + sizeof(*memmap));
-        uint32_t pos = sizeof(*memmap);
+        uint32_t pos = offsetof(multiboot2_tag_t, memmap) + sizeof(*memmap);
 
         while ((pos < length) && (e820counter < MEMMAP_E820_MAX_RECORDS)) {