Changeset 0b414b5 in mainline for kernel/arch/sparc64/src

Timestamp:

2006-10-02T21:07:23Z (19 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

233af8c5

Parents:

36db5ac

Message:

Extend the OFW device tree node with a void pointer. The boot loader is
supposed to reset all pointers in all nodes. The kernel uses the pointer
to recognize that a particular device has already been visited and initialized.

Read interrupt mapping from the OFW device tree for FHC devices (z8530) and
EBUS devices (ns16550). In case of FHC devices, remove hardwired values from
the code and use only values read from the tree. FHC initialization is started
when a FHC device wants to map its interrupt. In case of EBUS devices, map
the interrupt to INO. Interrupt enabling in the interrupt controller for that
specific interrupt is not implemented yet.

Location:

kernel/arch/sparc64/src

Files:

• drivers/fhc.c (modified) (1 diff)
• drivers/kbd.c (modified) (4 diffs)
• trap/interrupt.c (modified) (1 diff)

kernel/arch/sparc64/src/drivers/fhc.c

@@ -42 +42 @@
 #include <arch/drivers/fhc.h>
 #include <arch/mm/page.h>
+#include <mm/slab.h>
 #include <arch/types.h>
 #include <typedefs.h>
-
+#include <genarch/ofw/ofw_tree.h>
 #include <genarch/kbd/z8530.h>
 
-volatile uint32_t *fhc = NULL;
+fhc_t *central_fhc = NULL;
 
-#define FHC_UART_ADDR   0x1fff8808000ULL                /* hardcoded for Simics simulation */
+/**
+ * I suspect this must be hardcoded in the FHC.
+ * If it is not, than we can read all IMAP registers
+ * and get the complete mapping.
+ */
+#define FHC_UART_INO    0x39    
 
 #define FHC_UART_IMAP   0x0
 #define FHC_UART_ICLR   0x4
 
-void fhc_init(void)
+#define UART_IMAP_REG   4
+
+fhc_t *fhc_init(ofw_tree_node_t *node)
 {
-        fhc = (void *) hw_map(FHC_UART_ADDR, PAGE_SIZE);
+        fhc_t *fhc;
+        ofw_tree_property_t *prop;
 
-        fhc[FHC_UART_ICLR] = 0;
-        fhc[FHC_UART_IMAP] = 0x80000000;
+        prop = ofw_tree_getprop(node, "reg");
+        
+        if (!prop || !prop->value)
+                return NULL;
+                
+        count_t regs = prop->size / sizeof(ofw_central_reg_t);
+        if (regs + 1 < UART_IMAP_REG)
+                return NULL;
+
+        ofw_central_reg_t *reg = &((ofw_central_reg_t *) prop->value)[UART_IMAP_REG];
+
+        uintptr_t paddr;
+        if (!ofw_central_apply_ranges(node->parent, reg, &paddr))
+                return NULL;
+
+        fhc = (fhc_t *) malloc(sizeof(fhc_t), FRAME_ATOMIC);
+        if (!fhc)
+                return NULL;
+
+        fhc->uart_imap = (uint32_t *) hw_map(paddr, reg->size);
+        
+        return fhc;
 }
 
-void fhc_uart_reset(void)
+void fhc_enable_interrupt(fhc_t *fhc, int ino)
 {
-        fhc[FHC_UART_ICLR] = 0;
+        switch (ino) {
+        case FHC_UART_INO:
+                fhc->uart_imap[FHC_UART_ICLR] = 0x0;
+                fhc->uart_imap[FHC_UART_IMAP] = 0x80000000;
+                break;
+        default:
+                panic("Unexpected INO (%d)\n", ino);
+                break;
+        }
+}
+
+void fhc_clear_interrupt(fhc_t *fhc, int ino)
+{
+        ASSERT(fhc->uart_imap);
+
+        switch (ino) {
+        case FHC_UART_INO:
+                fhc->uart_imap[FHC_UART_ICLR] = 0;
+                break;
+        default:
+                panic("Unexpected INO (%d)\n", ino);
+                break;
+        }
 }
 

kernel/arch/sparc64/src/drivers/kbd.c

@@ -69 +69 @@
         name = ofw_tree_node_name(node);
         
+        /*
+         * Determine keyboard serial controller type.
+         */
         if (strcmp(name, "zs") == 0)
                 kbd_type = KBD_Z8530;
@@ -79 +82 @@
         }
         
+        /*
+         * Read 'interrupts' property.
+         */
+        uint32_t interrupts;
+        prop = ofw_tree_getprop(node, "interrupts");
+        if (!prop || !prop->value)
+                panic("Can't find \"interrupts\" property.\n");
+        interrupts = *((uint32_t *) prop->value);
+
+        /*
+         * Read 'reg' property.
+         */
         prop = ofw_tree_getprop(node, "reg");
-        if (!prop)
+        if (!prop || !prop->value)
                 panic("Can't find \"reg\" property.\n");
         
         uintptr_t pa;
         size_t size;
+        int ino;
         
         switch (kbd_type) {
@@ -93 +109 @@
                         return;
                 }
+                if (!ofw_fhc_map_interrupts(node->parent, ((ofw_fhc_reg_t *) prop->value), interrupts, &ino)) {
+                        printf("Failed to determine keyboard interrupts.\n");
+                        return;
+                }
                 break;
         case KBD_NS16550:
@@ -98 +118 @@
                 if (!ofw_ebus_apply_ranges(node->parent, ((ofw_ebus_reg_t *) prop->value) , &pa)) {
                         printf("Failed to determine keyboard address.\n");
+                        return;
+                }
+                if (!ofw_ebus_map_interrupts(node->parent, ((ofw_ebus_reg_t *) prop->value), interrupts, &ino)) {
+                        printf("Failed to determine keyboard interrupts.\n");
                         return;
                 }

kernel/arch/sparc64/src/trap/interrupt.c

@@ -97 +97 @@
                 else
                         ipc_irq_send_notif(0);
-                fhc_uart_reset();
+                fhc_clear_interrupt(central_fhc, data0);
                 break;