Changeset 8d2760f in mainline for kernel/genarch


Ignore:
Timestamp:
2008-11-29T20:24:47Z (17 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
57e76cb
Parents:
dfd77382
Message:

Add additional members to the irq_t structure so that an interrupt-driven driver
does not need to know how to clear the level interrupt. The z8530 was modified
in this way and is much more generic. The ns16550 driver has also been modified,
but awaits testing. The sparc64 interrupt mapping and dispatch code is now using
the new info and calls the clear-interrupt-routine itself.

Location:
kernel/genarch
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • kernel/genarch/include/kbd/ns16550.h

    rdfd77382 r8d2760f  
    3939
    4040#include <console/chardev.h>
     41#include <ddi/irq.h>
    4142#include <ipc/irq.h>
    4243
    43 extern void ns16550_init(devno_t devno, inr_t inr, uintptr_t vaddr);
     44extern void ns16550_init(devno_t, uintptr_t, inr_t, cir_t, void *);
    4445extern void ns16550_poll(void);
    4546extern void ns16550_grab(void);
    4647extern void ns16550_release(void);
    47 extern char ns16550_key_read(chardev_t *d);
     48extern char ns16550_key_read(chardev_t *);
    4849extern irq_ownership_t ns16550_claim(void);
    49 extern void ns16550_irq_handler(irq_t *irq, void *arg, ...);
     50extern void ns16550_irq_handler(irq_t *, void *, ...);
    5051
    5152#include <arch/types.h>

  • kernel/genarch/include/kbd/z8530.h

    rdfd77382 r8d2760f  
    4040#include <console/chardev.h>
    4141#include <ipc/irq.h>
     42#include <ddi/irq.h>
    4243
    4344extern bool z8530_belongs_to_kernel;
    4445
    45 extern void z8530_init(devno_t devno, inr_t inr, uintptr_t vaddr);
     46extern void z8530_init(devno_t, uintptr_t, inr_t, cir_t, void *);
    4647extern void z8530_poll(void);
    4748extern void z8530_grab(void);
    4849extern void z8530_release(void);
    4950extern void z8530_interrupt(void);
    50 extern char z8530_key_read(chardev_t *d);
     51extern char z8530_key_read(chardev_t *);
    5152extern irq_ownership_t z8530_claim(void);
    52 extern void z8530_irq_handler(irq_t *irq, void *arg, ...);
     53extern void z8530_irq_handler(irq_t *, void *, ...);
    5354
    5455#endif

  • kernel/genarch/include/ofw/ofw_tree.h

    rdfd77382 r8d2760f  
    3131
    3232#include <arch/types.h>
     33#include <ddi/irq.h>
    3334#include <typedefs.h>
    3435
    … …  
    4445        ofw_tree_node_t *child;
    4546
    46         uint32_t node_handle;                   /**< Old OpenFirmware node handle. */
    47 
    48         char *da_name;                          /**< Disambigued name. */
    49 
    50         unsigned properties;                    /**< Number of properties. */
     47        uint32_t node_handle;           /**< Old OpenFirmware node handle. */
     48
     49        char *da_name;                  /**< Disambigued name. */
     50
     51        unsigned properties;            /**< Number of properties. */
    5152        ofw_tree_property_t *property;
    5253       
    … …  
    106107        uint32_t child_base;
    107108        uint32_t parent_space;
    108         uint64_t parent_base;           /* group phys.mid and phys.lo together */
     109        uint64_t parent_base;   /* group phys.mid and phys.lo together */
    109110        uint32_t size;
    110111} __attribute__ ((packed));
    … …  
    128129
    129130struct ofw_pci_reg {
    130         uint32_t space;                 /* needs to be masked to obtain pure space id */
    131         uint64_t addr;                  /* group phys.mid and phys.lo together */
     131        uint32_t space;         /* needs to be masked to obtain pure space id */
     132        uint64_t addr;          /* group phys.mid and phys.lo together */
    132133        uint64_t size;
    133134} __attribute__ ((packed));
    … …  
    136137struct ofw_pci_range {
    137138        uint32_t space;
    138         uint64_t child_base;            /* group phys.mid and phys.lo together */
     139        uint64_t child_base;    /* group phys.mid and phys.lo together */
    139140        uint64_t parent_base;
    140141        uint64_t size;
    … …  
    161162typedef struct ofw_upa_reg ofw_upa_reg_t;
    162163
    163 extern void ofw_tree_init(ofw_tree_node_t *root);
     164extern void ofw_tree_init(ofw_tree_node_t *);
    164165extern void ofw_tree_print(void);
    165 extern const char *ofw_tree_node_name(const ofw_tree_node_t *node);
    166 extern ofw_tree_node_t *ofw_tree_lookup(const char *path);
    167 extern ofw_tree_property_t *ofw_tree_getprop(const ofw_tree_node_t *node, const char *name);
    168 extern ofw_tree_node_t *ofw_tree_find_child(ofw_tree_node_t *node, const char *name);
    169 extern ofw_tree_node_t *ofw_tree_find_child_by_device_type(ofw_tree_node_t *node, const char *device_type);
    170 extern ofw_tree_node_t *ofw_tree_find_peer_by_device_type(ofw_tree_node_t *node, const char *device_type);
    171 extern ofw_tree_node_t *ofw_tree_find_node_by_handle(ofw_tree_node_t *root, uint32_t handle);
    172 
    173 extern bool ofw_fhc_apply_ranges(ofw_tree_node_t *node, ofw_fhc_reg_t *reg, uintptr_t *pa);
    174 extern bool ofw_central_apply_ranges(ofw_tree_node_t *node, ofw_central_reg_t *reg, uintptr_t *pa);
    175 extern bool ofw_ebus_apply_ranges(ofw_tree_node_t *node, ofw_ebus_reg_t *reg, uintptr_t *pa);
    176 extern bool ofw_pci_apply_ranges(ofw_tree_node_t *node, ofw_pci_reg_t *reg, uintptr_t *pa);
    177 extern bool ofw_sbus_apply_ranges(ofw_tree_node_t *node, ofw_sbus_reg_t *reg, uintptr_t *pa);
    178 extern bool ofw_upa_apply_ranges(ofw_tree_node_t *node, ofw_upa_reg_t *reg, uintptr_t *pa);
    179 
    180 extern bool ofw_pci_reg_absolutize(ofw_tree_node_t *node, ofw_pci_reg_t *reg, ofw_pci_reg_t *out);
    181 
    182 extern bool ofw_fhc_map_interrupt(ofw_tree_node_t *node, ofw_fhc_reg_t *reg, uint32_t interrupt, int *inr);
    183 extern bool ofw_ebus_map_interrupt(ofw_tree_node_t *node, ofw_ebus_reg_t *reg, uint32_t interrupt, int *inr);
    184 extern bool ofw_pci_map_interrupt(ofw_tree_node_t *node, ofw_pci_reg_t *reg, int ino, int *inr);
     166extern const char *ofw_tree_node_name(const ofw_tree_node_t *);
     167extern ofw_tree_node_t *ofw_tree_lookup(const char *);
     168extern ofw_tree_property_t *ofw_tree_getprop(const ofw_tree_node_t *,
     169    const char *);
     170extern ofw_tree_node_t *ofw_tree_find_child(ofw_tree_node_t *, const char *);
     171extern ofw_tree_node_t *ofw_tree_find_child_by_device_type(ofw_tree_node_t *,
     172    const char *);
     173extern ofw_tree_node_t *ofw_tree_find_peer_by_device_type(ofw_tree_node_t *,
     174    const char *);
     175extern ofw_tree_node_t *ofw_tree_find_node_by_handle(ofw_tree_node_t *,
     176    uint32_t);
     177
     178extern bool ofw_fhc_apply_ranges(ofw_tree_node_t *, ofw_fhc_reg_t *,
     179    uintptr_t *);
     180extern bool ofw_central_apply_ranges(ofw_tree_node_t *, ofw_central_reg_t *,
     181    uintptr_t *);
     182extern bool ofw_ebus_apply_ranges(ofw_tree_node_t *, ofw_ebus_reg_t *,
     183    uintptr_t *);
     184extern bool ofw_pci_apply_ranges(ofw_tree_node_t *, ofw_pci_reg_t *,
     185    uintptr_t *);
     186extern bool ofw_sbus_apply_ranges(ofw_tree_node_t *, ofw_sbus_reg_t *,
     187    uintptr_t *);
     188extern bool ofw_upa_apply_ranges(ofw_tree_node_t *, ofw_upa_reg_t *,
     189    uintptr_t *);
     190
     191extern bool ofw_pci_reg_absolutize(ofw_tree_node_t *, ofw_pci_reg_t *,
     192    ofw_pci_reg_t *);
     193
     194extern bool ofw_fhc_map_interrupt(ofw_tree_node_t *, ofw_fhc_reg_t *,
     195    uint32_t, int *, cir_t *, void **);
     196extern bool ofw_ebus_map_interrupt(ofw_tree_node_t *, ofw_ebus_reg_t *,
     197    uint32_t, int *, cir_t *, void **);
     198extern bool ofw_pci_map_interrupt(ofw_tree_node_t *, ofw_pci_reg_t *,
     199    int, int *, cir_t *, void **);
    185200
    186201#endif

  • kernel/genarch/src/kbd/ns16550.c

    rdfd77382 r8d2760f  
    108108/** Initialize ns16550.
    109109 *
    110  * @param devno Device number.
    111  * @param inr Interrupt number.
    112  * @param vaddr Virtual address of device's registers.
    113  */
    114 void ns16550_init(devno_t devno, inr_t inr, ioport_t port)
     110 * @param devno         Device number.
     111 * @param port          Virtual/IO address of device's registers.
     112 * @param inr           Interrupt number.
     113 * @param cir           Clear interrupt function.
     114 * @param cir_arg       First argument to cir.
     115 */
     116void
     117ns16550_init(devno_t devno, ioport_t port, inr_t inr, cir_t cir, void *cir_arg)
    115118{
    116119        chardev_initialize("ns16550_kbd", &kbrd, &ops);
    … …  
    125128        ns16550_irq.claim = ns16550_claim;
    126129        ns16550_irq.handler = ns16550_irq_handler;
     130        ns16550_irq.cir = cir;
     131        ns16550_irq.cir_arg = cir_arg;
    127132        irq_register(&ns16550_irq);
    128133       

  • kernel/genarch/src/kbd/z8530.c

    rdfd77382 r8d2760f  
    4444#include <arch/interrupt.h>
    4545#include <arch/drivers/kbd.h>
    46 #include <arch/drivers/fhc.h>
    4746#include <cpu.h>
    4847#include <arch/asm.h>
    … …  
    8483        z8530_write_a(&z8530, WR0, WR0_TX_IP_RST);
    8584
    86         z8530_write_a(&z8530, WR1, WR1_IARCSC);         /* interrupt on all characters */
     85        /* interrupt on all characters */
     86        z8530_write_a(&z8530, WR1, WR1_IARCSC);
    8787
    8888        /* 8 bits per character and enable receiver */
    8989        z8530_write_a(&z8530, WR3, WR3_RX8BITSCH | WR3_RX_ENABLE);
    9090       
    91         z8530_write_a(&z8530, WR9, WR9_MIE);            /* Master Interrupt Enable. */
     91        /* Master Interrupt Enable. */
     92        z8530_write_a(&z8530, WR9, WR9_MIE);
    9293       
    9394        spinlock_lock(&z8530_irq.lock);
    … …  
    109110
    110111/** Initialize z8530. */
    111 void z8530_init(devno_t devno, inr_t inr, uintptr_t vaddr)
     112void
     113z8530_init(devno_t devno, uintptr_t vaddr, inr_t inr, cir_t cir, void *cir_arg)
    112114{
    113115        chardev_initialize("z8530_kbd", &kbrd, &ops);
    … …  
    122124        z8530_irq.claim = z8530_claim;
    123125        z8530_irq.handler = z8530_irq_handler;
     126        z8530_irq.cir = cir;
     127        z8530_irq.cir_arg = cir_arg;
    124128        irq_register(&z8530_irq);
    125129
    … …  
    198202void z8530_irq_handler(irq_t *irq, void *arg, ...)
    199203{
    200         /*
    201          * So far, we know we got this interrupt through the FHC.
    202          * Since we don't have enough documentation about the FHC
    203          * and because the interrupt looks like level sensitive,
    204          * we cannot handle it by scheduling one of the level
    205          * interrupt traps. Process the interrupt directly.
    206          */
    207204        if (irq->notif_cfg.notify && irq->notif_cfg.answerbox)
    208205                ipc_irq_send_notif(irq);
    209206        else
    210207                z8530_interrupt();
    211         fhc_clear_interrupt(central_fhc, irq->inr);
    212208}
    213209

  • kernel/genarch/src/ofw/ebus.c

    rdfd77382 r8d2760f  
    4545
    4646/** Apply EBUS ranges to EBUS register. */
    47 bool ofw_ebus_apply_ranges(ofw_tree_node_t *node, ofw_ebus_reg_t *reg, uintptr_t *pa)
     47bool
     48ofw_ebus_apply_ranges(ofw_tree_node_t *node, ofw_ebus_reg_t *reg, uintptr_t *pa)
    4849{
    4950        ofw_tree_property_t *prop;
    … …  
    6364                if (reg->space != range[i].child_space)
    6465                        continue;
    65                 if (overlaps(reg->addr, reg->size, range[i].child_base, range[i].size)) {
     66                if (overlaps(reg->addr, reg->size, range[i].child_base,
     67                    range[i].size)) {
    6668                        ofw_pci_reg_t pci_reg;
    6769                       
    6870                        pci_reg.space = range[i].parent_space;
    69                         pci_reg.addr = range[i].parent_base + (reg->addr - range[i].child_base);
     71                        pci_reg.addr = range[i].parent_base +
     72                            (reg->addr - range[i].child_base);
    7073                        pci_reg.size = reg->size;
    7174                       
    … …  
    7780}
    7881
    79 bool ofw_ebus_map_interrupt(ofw_tree_node_t *node, ofw_ebus_reg_t *reg, uint32_t interrupt, int *inr)
     82bool
     83ofw_ebus_map_interrupt(ofw_tree_node_t *node, ofw_ebus_reg_t *reg,
     84    uint32_t interrupt, int *inr, cir_t *cir, void **cir_arg)
    8085{
    8186        ofw_tree_property_t *prop;
    … …  
    105110        unsigned int i;
    106111        for (i = 0; i < count; i++) {
    107                 if ((intr_map[i].space == space) && (intr_map[i].addr == addr)
    108                         && (intr_map[i].intr == intr))
     112                if ((intr_map[i].space == space) &&
     113                    (intr_map[i].addr == addr) && (intr_map[i].intr == intr))
    109114                        goto found;
    110115        }
    … …  
    114119        /*
    115120         * We found the device that functions as an interrupt controller
    116          * for the interrupt. We also found partial mapping from interrupt to INO.
     121         * for the interrupt. We also found partial mapping from interrupt to
     122         * INO.
    117123         */
    118124
    119         controller = ofw_tree_find_node_by_handle(ofw_tree_lookup("/"), intr_map[i].controller_handle);
     125        controller = ofw_tree_find_node_by_handle(ofw_tree_lookup("/"),
     126            intr_map[i].controller_handle);
    120127        if (!controller)
    121128                return false;
    … …  
    131138         * Let the PCI do the next step in mapping the interrupt.
    132139         */
    133         if (!ofw_pci_map_interrupt(controller, NULL, intr_map[i].controller_ino, inr))
     140        if (!ofw_pci_map_interrupt(controller, NULL, intr_map[i].controller_ino,
     141            inr, cir, cir_arg))
    134142                return false;
    135143

  • kernel/genarch/src/ofw/fhc.c

    rdfd77382 r8d2760f  
    110110}
    111111
    112 bool ofw_fhc_map_interrupt(ofw_tree_node_t *node, ofw_fhc_reg_t *reg, uint32_t interrupt, int *inr)
     112bool
     113ofw_fhc_map_interrupt(ofw_tree_node_t *node, ofw_fhc_reg_t *reg,
     114    uint32_t interrupt, int *inr, cir_t *cir, void **cir_arg)
    113115{
    114116        fhc_t *fhc = NULL;
    … …  
    127129       
    128130        *inr = interrupt;
     131        *cir = fhc_clear_interrupt;
     132        *cir_arg = fhc;
    129133        return true;
    130134}

  • kernel/genarch/src/ofw/pci.c

    rdfd77382 r8d2760f  
    5050#define PCI_IGN                 0x1f
    5151
    52 bool ofw_pci_apply_ranges(ofw_tree_node_t *node, ofw_pci_reg_t *reg, uintptr_t *pa)
     52bool
     53ofw_pci_apply_ranges(ofw_tree_node_t *node, ofw_pci_reg_t *reg, uintptr_t *pa)
    5354{
    5455        ofw_tree_property_t *prop;
    … …  
    6970       
    7071        for (i = 0; i < ranges; i++) {
    71                 if ((reg->space & PCI_SPACE_MASK) != (range[i].space & PCI_SPACE_MASK))
     72                if ((reg->space & PCI_SPACE_MASK) !=
     73                    (range[i].space & PCI_SPACE_MASK))
    7274                        continue;
    73                 if (overlaps(reg->addr, reg->size, range[i].child_base, range[i].size)) {
    74                         *pa = range[i].parent_base + (reg->addr - range[i].child_base);
     75                if (overlaps(reg->addr, reg->size, range[i].child_base,
     76                    range[i].size)) {
     77                        *pa = range[i].parent_base +
     78                            (reg->addr - range[i].child_base);
    7579                        return true;
    7680                }
    … …  
    8084}
    8185
    82 bool ofw_pci_reg_absolutize(ofw_tree_node_t *node, ofw_pci_reg_t *reg, ofw_pci_reg_t *out)
     86bool
     87ofw_pci_reg_absolutize(ofw_tree_node_t *node, ofw_pci_reg_t *reg,
     88    ofw_pci_reg_t *out)
    8389{
    8490        if (reg->space & PCI_ABS_MASK) {
    … …  
    104110       
    105111        for (i = 0; i < assigned_addresses; i++) {
    106                 if ((assigned_address[i].space & PCI_REG_MASK) == (reg->space & PCI_REG_MASK)) {
     112                if ((assigned_address[i].space & PCI_REG_MASK) ==
     113                    (reg->space & PCI_REG_MASK)) {
    107114                        out->space = assigned_address[i].space;
    108115                        out->addr = reg->addr + assigned_address[i].addr;
    … …  
    120127 * to a PCI bridge.
    121128 */
    122 bool ofw_pci_map_interrupt(ofw_tree_node_t *node, ofw_pci_reg_t *reg, int ino, int *inr)
     129bool
     130ofw_pci_map_interrupt(ofw_tree_node_t *node, ofw_pci_reg_t *reg, int ino,
     131    int *inr, cir_t *cir, void **cir_arg)
    123132{
    124133        pci_t *pci = node->device;
    … …  
    133142
    134143        *inr = (PCI_IGN << IGN_SHIFT) | ino;
     144        *cir = pci_clear_interrupt;
     145        *cir_arg = pci;
    135146
    136147        return true;
Note: See TracChangeset for help on using the changeset viewer.