No empty .Rs/.Re

[netbsd-mini2440.git] / gnu / dist / gdb6 / sim / ppc / hw_opic.c

/*  This file is part of the program psim.

    Copyright (C) 1994-1996, Andrew Cagney <cagney@highland.com.au>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    */


#ifndef _HW_OPIC_C_
#define _HW_OPIC_C_

#include "device_table.h"

#ifdef HAVE_STRING_H
#include <string.h>
#else
#ifdef HAVE_STRINGS_H
#include <strings.h>
#endif
#endif


/* DEVICE


   opic - Open Programmable Interrupt Controller (OpenPIC)


   DESCRIPTION


   This device implements the core of the OpenPIC interrupt controller
   as described in the OpenPIC specification 1.2 and other related
   documents.

   The model includes:

   o    Up to 2048 external interrupt sources

   o    The four count down timers

   o    The four interprocessor multicast interrupts

   o    multiprocessor support

   o    Full tracing to assist help debugging

   o    Support for all variations of edge/level x high/low polarity.



   PROPERTIES


   reg = <address> <size> ... (required)

   Determine where the device lives in the parents address space.  The
   first <<address>> <<size>> pair specifies the address of the
   interrupt destination unit (which might contain an interrupt source
   unit) while successive reg entries specify additional interrupt
   source units.

   Note that for an <<opic>> device attached to a <<pci>> bus, the
   first <<reg>> entry may need to be ignored it will be the address
   of the devices configuration registers.


   interrupt-ranges = <int-number> <range> ... (required)

   A list of pairs.  Each pair corresponds to a block of interrupt
   source units (the address of which being specified by the
   corresponding reg tupple).  <<int-number>> is the number of the
   first interrupt in the block while <<range>> is the number of
   interrupts in the block.


   timer-frequency = <integer>  (optional)

   If present, specifies the default value of the timer frequency
   reporting register.  By default a value of 1 HZ is used.  The value
   is arbitrary, the timers are always updated once per machine cycle.


   vendor-identification = <integer>  (optional)

   If present, specifies the value to be returned when the vendor
   identification register is read.


   EXAMPLES


   See the test suite directory:

   |  psim-test/hw-opic


   BUGS

   For an OPIC controller attached to a PCI bus, it is not clear what
   the value of the <<reg>> and <<interrupt-ranges>> properties should
   be.  In particular, the PCI firmware bindings require the first
   value of the <<reg>> property to specify the devices configuration
   address while the OpenPIC bindings require that same entry to
   specify the address of the Interrupt Delivery Unit.  This
   implementation checks for and, if present, ignores any
   configuration address (and its corresponding <<interrupt-ranges>>
   entry).

   The OpenPIC specification requires the controller to be fair when
   distributing interrupts between processors.  At present the
   algorithm used isn't fair.  It is biased towards processor zero.

   The OpenPIC specification includes a 8259 pass through mode.  This
   is not supported.


   REFERENCES

   
   PowerPC Multiprocessor Interrupt Controller (MPIC), January 19,
   1996. Available from IBM.


   The Open Programmable Interrupt Controller (PIC) Register Interface
   Specification Revision 1.2.  Issue Date: Opctober 1995.  Available
   somewhere on AMD's web page (http://www.amd.com/)


   PowerPC Microprocessor Common Hardware Reference Platform (CHRP)
   System bindings to: IEEE Std 1275-1994 Standard for Boot
   (Initialization, Configuration) Firmware.  Revision 1.2b (INTERIM
   DRAFT).  April 22, 1996.  Available on the Open Firmware web site
   http://playground.sun.com/p1275/.


   */


/* forward types */

typedef struct _hw_opic_device hw_opic_device;


/* bounds */

enum {
  max_nr_interrupt_sources = 2048,
  max_nr_interrupt_destinations = 32,
  max_nr_task_priorities = 16,
};


enum {
  opic_alignment = 16,
};


/* global configuration register */

enum {
  gcr0_8259_bit = 0x20000000,
  gcr0_reset_bit = 0x80000000,
};


/* offsets and sizes */

enum {
  idu_isu_base = 0x10000,
  sizeof_isu_register_block = 32,
  idu_per_processor_register_base = 0x20000,
  sizeof_idu_per_processor_register_block = 0x1000,
  idu_timer_base = 0x01100,
  sizeof_timer_register_block = 0x00040,
};


/* Interrupt sources */

enum {
  isu_mask_bit = 0x80000000,
  isu_active_bit = 0x40000000,
  isu_multicast_bit = 0x20000000,
  isu_positive_polarity_bit = 0x00800000,
  isu_level_triggered_bit = 0x00400000,
  isu_priority_shift = 16,
  isu_vector_bits = 0x000000ff,
};


typedef struct _opic_interrupt_source {
  unsigned is_masked; /* left in place */
  unsigned is_multicast; /* left in place */
  unsigned is_positive_polarity; /* left in place */
  unsigned is_level_triggered; /* left in place */
  unsigned priority;
  unsigned vector;
  /* misc */
  int nr;
  unsigned destination;
  unsigned pending;
  unsigned in_service;
} opic_interrupt_source;


/* interrupt destinations (normally processors) */

typedef struct _opic_interrupt_destination {
  int nr;
  unsigned base_priority;
  opic_interrupt_source *current_pending;
  opic_interrupt_source *current_in_service;
  unsigned bit;
  int init_port;
  int intr_port;
} opic_interrupt_destination;


/* address map descriptors */

typedef struct _opic_isu_block { /* interrupt source unit block */
  int space;
  unsigned_word address;
  unsigned size;
  unsigned_cell int_number;
  unsigned_cell range;
  int reg;
} opic_isu_block;


typedef struct _opic_idu { /* interrupt delivery unit */
  int reg;
  int space;
  unsigned_word address;
  unsigned size;
} opic_idu;

typedef enum {
  /* bad */
  invalid_opic_register,
  /* interrupt source */
  interrupt_source_N_destination_register,
  interrupt_source_N_vector_priority_register,
  /* timers */
  timer_N_destination_register,
  timer_N_vector_priority_register,
  timer_N_base_count_register,
  timer_N_current_count_register,
  timer_frequency_reporting_register,
  /* inter-processor interrupts */
  ipi_N_vector_priority_register,
  ipi_N_dispatch_register,
  /* global configuration */
  spurious_vector_register,
  processor_init_register,
  vendor_identification_register,
  global_configuration_register_N,
  feature_reporting_register_N,
  /* per processor */
  end_of_interrupt_register_N,
  interrupt_acknowledge_register_N,
  current_task_priority_register_N,
} opic_register;

static const char *
opic_register_name(opic_register type)
{
  switch (type) {
  case invalid_opic_register: return "invalid_opic_register";
  case interrupt_source_N_destination_register: return "interrupt_source_N_destination_register";
  case interrupt_source_N_vector_priority_register: return "interrupt_source_N_vector_priority_register";
  case timer_N_destination_register: return "timer_N_destination_register";
  case timer_N_vector_priority_register: return "timer_N_vector_priority_register";
  case timer_N_base_count_register: return "timer_N_base_count_register";
  case timer_N_current_count_register: return "timer_N_current_count_register";
  case timer_frequency_reporting_register: return "timer_frequency_reporting_register";
  case ipi_N_vector_priority_register: return "ipi_N_vector_priority_register";
  case ipi_N_dispatch_register: return "ipi_N_dispatch_register";
  case spurious_vector_register: return "spurious_vector_register";
  case processor_init_register: return "processor_init_register";
  case vendor_identification_register: return "vendor_identification_register";
  case global_configuration_register_N: return "global_configuration_register_N";
  case feature_reporting_register_N: return "feature_reporting_register_N";
  case end_of_interrupt_register_N: return "end_of_interrupt_register_N";
  case interrupt_acknowledge_register_N: return "interrupt_acknowledge_register_N";
  case current_task_priority_register_N: return "current_task_priority_register_N";
  }
  return NULL;
}



/* timers */

typedef struct _opic_timer {
  int nr;
  device *me; /* find my way home */
  hw_opic_device *opic; /* ditto */
  unsigned base_count;
  int inhibited;
  signed64 count; /* *ONLY* if inhibited */
  event_entry_tag timeout_event;
  opic_interrupt_source *interrupt_source;
} opic_timer;


/* the OPIC */

struct _hw_opic_device {

  /* vendor id */
  unsigned vendor_identification;

  /* interrupt destinations - processors */
  int nr_interrupt_destinations;
  opic_interrupt_destination *interrupt_destination;
  unsigned sizeof_interrupt_destination;

  /* bogus interrupts */
  int spurious_vector;

  /* interrupt sources - external interrupt source units + extra internal ones */
  int nr_interrupt_sources;
  opic_interrupt_source *interrupt_source;
  unsigned sizeof_interrupt_source;

  /* external interrupts */
  int nr_external_interrupts;
  opic_interrupt_source *external_interrupt_source;

  /* inter-processor-interrupts */
  int nr_interprocessor_interrupts;
  opic_interrupt_source *interprocessor_interrupt_source;

  /* timers */
  int nr_timer_interrupts;
  opic_timer *timer;
  unsigned sizeof_timer;
  opic_interrupt_source *timer_interrupt_source;
  unsigned timer_frequency;

  /* init register */
  unsigned32 init;

  /* address maps */
  opic_idu idu;
  int nr_isu_blocks;
  opic_isu_block *isu_block;
};


static void
hw_opic_init_data(device *me)
{
  hw_opic_device *opic = (hw_opic_device*)device_data(me);
  int isb;
  int idu_reg;
  int nr_isu_blocks;
  int i;

  /* determine the first valid reg property entry (there could be
     leading reg entries with invalid (zero) size fields) and the
     number of isu entries found in the reg property. */
  idu_reg = 0;
  nr_isu_blocks = 0;
  while (1) {
    reg_property_spec unit;
    int attach_space;
    unsigned_word attach_address;
    unsigned attach_size;
    if (!device_find_reg_array_property(me, "reg", idu_reg + nr_isu_blocks,
                                        &unit))
      break;
    if (nr_isu_blocks > 0
        || (device_address_to_attach_address(device_parent(me), &unit.address,
                                             &attach_space, &attach_address,
                                             me)
            && device_size_to_attach_size(device_parent(me), &unit.size,
                                          &attach_size,
                                          me))) {
      /* we count any thing once we've found one valid address/size pair */
      nr_isu_blocks += 1;
    }
    else {
      idu_reg += 1;
    }
  }

  /* determine the number and location of the multiple interrupt
     source units and the single interrupt delivery unit */
  if (opic->isu_block == NULL) {
    int reg_nr;
    opic->nr_isu_blocks = nr_isu_blocks;
    opic->isu_block = zalloc(sizeof(opic_isu_block) * opic->nr_isu_blocks);
    isb = 0;
    reg_nr = idu_reg;
    while (isb < opic->nr_isu_blocks) {
      reg_property_spec reg;
      if (!device_find_reg_array_property(me, "reg", reg_nr, &reg))
        device_error(me, "reg property missing entry number %d", reg_nr);
      opic->isu_block[isb].reg = reg_nr;
      if (!device_address_to_attach_address(device_parent(me), &reg.address,
                                            &opic->isu_block[isb].space,
                                            &opic->isu_block[isb].address,
                                            me)
          || !device_size_to_attach_size(device_parent(me), &reg.size,
                                         &opic->isu_block[isb].size,
                                         me)) {
        device_error(me, "reg property entry %d invalid", reg_nr);
      }
      if (!device_find_integer_array_property(me, "interrupt-ranges",
                                              reg_nr * 2,
                                              &opic->isu_block[isb].int_number)
          || !device_find_integer_array_property(me, "interrupt-ranges",
                                                 reg_nr * 2 + 1,
                                                 &opic->isu_block[isb].range))
        device_error(me, "missing or invalid interrupt-ranges property entry %d", reg_nr);
      /* first reg entry specifies the address of both the IDU and the
         first set of ISU registers, adjust things accordingly */
      if (reg_nr == idu_reg) {
        opic->idu.reg = opic->isu_block[isb].reg;
        opic->idu.space = opic->isu_block[isb].space;
        opic->idu.address = opic->isu_block[isb].address;
        opic->idu.size = opic->isu_block[isb].size;
        opic->isu_block[isb].address += idu_isu_base;
        opic->isu_block[isb].size = opic->isu_block[isb].range * (16 + 16);
      }
      /* was this a valid reg entry? */
      if (opic->isu_block[isb].range == 0) {
        opic->nr_isu_blocks -= 1;
      }
      else {
        opic->nr_external_interrupts += opic->isu_block[isb].range;
        isb++;
      }
      reg_nr++;
    }
  }
  DTRACE(opic, ("interrupt source unit block - effective number of blocks %d\n",
                (int)opic->nr_isu_blocks));


  /* the number of other interrupts */
  opic->nr_interprocessor_interrupts = 4;
  opic->nr_timer_interrupts = 4;


  /* create space for the interrupt source registers */
  if (opic->interrupt_source != NULL) {
    memset(opic->interrupt_source, 0, opic->sizeof_interrupt_source);
  }
  else {
    opic->nr_interrupt_sources = (opic->nr_external_interrupts
                                  + opic->nr_interprocessor_interrupts
                                  + opic->nr_timer_interrupts);
    if (opic->nr_interrupt_sources > max_nr_interrupt_sources)
      device_error(me, "number of interrupt sources exceeded");
    opic->sizeof_interrupt_source = (sizeof(opic_interrupt_source)
                                     * opic->nr_interrupt_sources);
    opic->interrupt_source = zalloc(opic->sizeof_interrupt_source);
    opic->external_interrupt_source = opic->interrupt_source;
    opic->interprocessor_interrupt_source = (opic->external_interrupt_source
                                             + opic->nr_external_interrupts);
    opic->timer_interrupt_source = (opic->interprocessor_interrupt_source
                                    + opic->nr_interprocessor_interrupts);
  }
  for (i = 0; i < opic->nr_interrupt_sources; i++) {
    opic_interrupt_source *source = &opic->interrupt_source[i];
    source->nr = i;
    source->is_masked = isu_mask_bit;
  }
  DTRACE(opic, ("interrupt sources - external %d, timer %d, ipi %d, total %d\n",
                opic->nr_external_interrupts,
                opic->nr_timer_interrupts,
                opic->nr_interprocessor_interrupts,
                opic->nr_interrupt_sources));


  /* timers or interprocessor interrupts */
  if (opic->timer != NULL)
    memset(opic->timer, 0, opic->sizeof_timer);
  else {
    opic->nr_timer_interrupts = 4;
    opic->sizeof_timer = sizeof(opic_timer) * opic->nr_timer_interrupts;
    opic->timer = zalloc(opic->sizeof_timer);
  }
  for (i = 0; i < opic->nr_timer_interrupts; i++) {
    opic_timer *timer = &opic->timer[i];
    timer->nr = i;
    timer->me = me;
    timer->opic = opic;
    timer->inhibited = 1;
    timer->interrupt_source = &opic->timer_interrupt_source[i];
  }
  if (device_find_property(me, "timer-frequency"))
    opic->timer_frequency = device_find_integer_property(me, "timer-frequency");
  else
    opic->timer_frequency = 1;


  /* create space for the interrupt destination registers */
  if (opic->interrupt_destination != NULL) {
    memset(opic->interrupt_destination, 0, opic->sizeof_interrupt_destination);
  }
  else {
    opic->nr_interrupt_destinations = tree_find_integer_property(me, "/openprom/options/smp");
    opic->sizeof_interrupt_destination = (sizeof(opic_interrupt_destination)
                                          * opic->nr_interrupt_destinations);
    opic->interrupt_destination = zalloc(opic->sizeof_interrupt_destination);
    if (opic->nr_interrupt_destinations > max_nr_interrupt_destinations)
      device_error(me, "number of interrupt destinations exceeded");
  }
  for (i = 0; i < opic->nr_interrupt_destinations; i++) {
    opic_interrupt_destination *dest = &opic->interrupt_destination[i];
    dest->bit = (1 << i);
    dest->nr = i;
    dest->init_port = (device_interrupt_decode(me, "init0", output_port)
                       + i);
    dest->intr_port = (device_interrupt_decode(me, "intr0", output_port)
                       + i);
    dest->base_priority = max_nr_task_priorities - 1;
  }
  DTRACE(opic, ("interrupt destinations - total %d\n",
                (int)opic->nr_interrupt_destinations));
  

  /* verify and print out the ISU's */
  for (isb = 0; isb < opic->nr_isu_blocks; isb++) {
    unsigned correct_size;
    if ((opic->isu_block[isb].address % opic_alignment) != 0)
      device_error(me, "interrupt source unit %d address not aligned to %d byte boundary",
                   isb, opic_alignment);
    correct_size = opic->isu_block[isb].range * sizeof_isu_register_block;
    if (opic->isu_block[isb].size != correct_size)
      device_error(me, "interrupt source unit %d (reg %d) has an incorrect size, should be 0x%x",
                   isb, opic->isu_block[isb].reg, correct_size);
    DTRACE(opic, ("interrupt source unit block %ld - address %d:0x%lx, size 0x%lx, int-number %ld, range %ld\n",
                  (long)isb,
                  (int)opic->isu_block[isb].space,
                  (unsigned long)opic->isu_block[isb].address,
                  (unsigned long)opic->isu_block[isb].size,
                  (long)opic->isu_block[isb].int_number,
                  (long)opic->isu_block[isb].range));
  }


  /* verify and print out the IDU */
  {
    unsigned correct_size;
    unsigned alternate_size;
    if ((opic->idu.address % opic_alignment) != 0)
      device_error(me, "interrupt delivery unit not aligned to %d byte boundary",
                   opic_alignment);
    correct_size = (idu_per_processor_register_base
                    + (sizeof_idu_per_processor_register_block
                       * opic->nr_interrupt_destinations));
    alternate_size = (idu_per_processor_register_base
                      + (sizeof_idu_per_processor_register_block
                         * max_nr_interrupt_destinations));
    if (opic->idu.size != correct_size
        && opic->idu.size != alternate_size)
      device_error(me, "interrupt delivery unit has incorrect size, should be 0x%x or 0x%x",
                   correct_size, alternate_size);
    DTRACE(opic, ("interrupt delivery unit - address %d:0x%lx, size 0x%lx\n",
                  (int)opic->idu.space,
                  (unsigned long)opic->idu.address,
                  (unsigned long)opic->idu.size));
  }

  /* initialize the init interrupts */
  opic->init = 0;


  /* vendor ident */
  if (device_find_property(me, "vendor-identification") != NULL)
    opic->vendor_identification = device_find_integer_property(me, "vendor-identification");
  else
    opic->vendor_identification = 0;

  /* misc registers */
  opic->spurious_vector = 0xff;

}


/* interrupt related actions */

static void
assert_interrupt(device *me,
                 hw_opic_device *opic,
                 opic_interrupt_destination *dest)
{
  ASSERT(dest >= opic->interrupt_destination);
  ASSERT(dest < opic->interrupt_destination + opic->nr_interrupt_destinations);
  DTRACE(opic, ("assert interrupt - intr port %d\n", dest->intr_port));
  device_interrupt_event(me, dest->intr_port, 1, NULL, 0);
}


static void
negate_interrupt(device *me,
                 hw_opic_device *opic,
                 opic_interrupt_destination *dest)
{
  ASSERT(dest >= opic->interrupt_destination);
  ASSERT(dest < opic->interrupt_destination + opic->nr_interrupt_destinations);
  DTRACE(opic, ("negate interrupt - intr port %d\n", dest->intr_port));
  device_interrupt_event(me, dest->intr_port, 0, NULL, 0);
}


static int
can_deliver(device *me,
            opic_interrupt_source *source,
            opic_interrupt_destination *dest)
{
  return (source != NULL && dest != NULL
          && source->priority > dest->base_priority
          && (dest->current_in_service == NULL
              || source->priority > dest->current_in_service->priority));
}


static unsigned
deliver_pending(device *me,
                hw_opic_device *opic,
                opic_interrupt_destination *dest)
{
  ASSERT(can_deliver(me, dest->current_pending, dest));
  dest->current_in_service = dest->current_pending;
  dest->current_in_service->in_service |= dest->bit;
  if (!dest->current_pending->is_level_triggered) {
    if (dest->current_pending->is_multicast)
      dest->current_pending->pending &= ~dest->bit;
    else
      dest->current_pending->pending = 0;
  }
  dest->current_pending = NULL;
  negate_interrupt(me, opic, dest);
  return dest->current_in_service->vector;
}


typedef enum {
  pending_interrupt,
  in_service_interrupt,
} interrupt_class;

static opic_interrupt_source *
find_interrupt_for_dest(device *me,
                        hw_opic_device *opic,
                        opic_interrupt_destination *dest,
                        interrupt_class class)
{
  int i;
  opic_interrupt_source *pending = NULL;
  for (i = 0; i < opic->nr_interrupt_sources; i++) {
    opic_interrupt_source *src = &opic->interrupt_source[i];
    /* is this a potential hit? */
    switch (class) {
    case in_service_interrupt:
      if ((src->in_service & dest->bit) == 0)
        continue;
      break;
    case pending_interrupt:
      if ((src->pending & dest->bit) == 0)
        continue;
      break;
    }
    /* see if it is the highest priority */
    if (pending == NULL)
      pending = src;
    else if (src->priority > pending->priority)
      pending = src;
  }
  return pending;
}


static opic_interrupt_destination *
find_lowest_dest(device *me, 
                 hw_opic_device *opic,
                 opic_interrupt_source *src)
{
  int i;
  opic_interrupt_destination *lowest = NULL;
  for (i = 0; i < opic->nr_interrupt_destinations; i++) {
    opic_interrupt_destination *dest = &opic->interrupt_destination[i];
    if (src->destination & dest->bit) {
      if (dest->base_priority < src->priority) {
        if (lowest == NULL)
          lowest = dest;
        else if (lowest->base_priority > dest->base_priority)
          lowest = dest;
        else if (lowest->current_in_service != NULL
                 && dest->current_in_service == NULL)
          lowest = dest; /* not doing anything */
        else if (lowest->current_in_service != NULL
                 && dest->current_in_service != NULL
                 && (lowest->current_in_service->priority
                     > dest->current_in_service->priority))
          lowest = dest; /* less urgent */
        /* FIXME - need to be more fair */      
      }
    }
  }
  return lowest;
}


static void
handle_interrupt(device *me,
                 hw_opic_device *opic,
                 opic_interrupt_source *src,
                 int asserted)
{
  if (src->is_masked) {
    DTRACE(opic, ("interrupt %d - ignore masked\n", src->nr));
  }
  else if (src->is_multicast) {
    /* always try to deliver multicast interrupts - just easier */
    int i;
    ASSERT(!src->is_level_triggered);
    ASSERT(src->is_positive_polarity);
    ASSERT(asserted);
    for (i = 0; i < opic->nr_interrupt_destinations; i++) {
      opic_interrupt_destination *dest = &opic->interrupt_destination[i];
      if (src->destination & dest->bit) {
        if (src->pending & dest->bit) {
          DTRACE(opic, ("interrupt %d - multicast still pending to %d\n",
                        src->nr, dest->nr));
        }
        else if (can_deliver(me, src, dest)) {
          dest->current_pending = src;
          src->pending |= dest->bit;
          assert_interrupt(me, opic, dest);
          DTRACE(opic, ("interrupt %d - multicast to %d\n",
                        src->nr, dest->nr));
        }
        else {
          src->pending |= dest->bit;
          DTRACE(opic, ("interrupt %d - multicast pending to %d\n",
                        src->nr, dest->nr));
        }
      }
    }
  }
  else if (src->is_level_triggered
           && src->is_positive_polarity
           && !asserted) {
    if (src->pending)
      DTRACE(opic, ("interrupt %d - ignore withdrawn (active high)\n",
                    src->nr));
    else
      DTRACE(opic, ("interrupt %d - ignore low level (active high)\n",
                    src->nr));
    ASSERT(!src->is_multicast);
    src->pending = 0;
  }
  else if (src->is_level_triggered
           && !src->is_positive_polarity
           && asserted) {
    if (src->pending)
      DTRACE(opic, ("interrupt %d - ignore withdrawn (active low)\n",
                    src->nr));
    else
      DTRACE(opic, ("interrupt %d - ignore high level (active low)\n",
                    src->nr));

    ASSERT(!src->is_multicast);
    src->pending = 0;
  }
  else if (!src->is_level_triggered
           && src->is_positive_polarity
           && !asserted) {
    DTRACE(opic, ("interrupt %d - ignore falling edge (positive edge trigered)\n",
                  src->nr));
  }
  else if (!src->is_level_triggered
           && !src->is_positive_polarity
           && asserted) {
    DTRACE(opic, ("interrupt %d - ignore rising edge (negative edge trigered)\n",
                  src->nr));
  }
  else if (src->in_service != 0) {
    /* leave the interrupt where it is */
    ASSERT(!src->is_multicast);
    ASSERT(src->pending == 0 || src->pending == src->in_service);
    src->pending = src->in_service;
    DTRACE(opic, ("interrupt %ld - ignore already in service to 0x%lx\n",
                  (long)src->nr, (long)src->in_service));
  }
  else if (src->pending != 0) {
    DTRACE(opic, ("interrupt %ld - ignore still pending to 0x%lx\n",
                  (long)src->nr, (long)src->pending));
  }
  else {
    /* delivery is needed */
    opic_interrupt_destination *dest = find_lowest_dest(me, opic, src);
    if (can_deliver(me, src, dest)) {
      dest->current_pending = src;
      src->pending = dest->bit;
      DTRACE(opic, ("interrupt %d - delivered to %d\n", src->nr, dest->nr));
      assert_interrupt(me, opic, dest);
    }
    else {
      src->pending = src->destination; /* any can take this */
      DTRACE(opic, ("interrupt %ld - pending to 0x%lx\n",
                    (long)src->nr, (long)src->pending));
    }
  }
}

static unsigned
do_interrupt_acknowledge_register_N_read(device *me,
                                         hw_opic_device *opic,
                                         int dest_nr)
{
  opic_interrupt_destination *dest = &opic->interrupt_destination[dest_nr];
  unsigned vector;

  ASSERT(dest_nr >= 0 && dest_nr < opic->nr_interrupt_destinations);
  ASSERT(dest_nr == dest->nr);

  /* try the current pending */
  if (can_deliver(me, dest->current_pending, dest)) {
    ASSERT(dest->current_pending->pending & dest->bit);
    vector = deliver_pending(me, opic, dest);
    DTRACE(opic, ("interrupt ack %d - entering %d (pending) - vector %d (%d), priority %d\n",
                  dest->nr,
                  dest->current_in_service->nr,
                  dest->current_in_service->vector, vector,
                  dest->current_in_service->priority));
  }
  else {
    /* try for something else */
    dest->current_pending = find_interrupt_for_dest(me, opic, dest, pending_interrupt);
    if (can_deliver(me, dest->current_pending, dest)) {
      vector = deliver_pending(me, opic, dest);    
      DTRACE(opic, ("interrupt ack %d - entering %d (not pending) - vector %d (%d), priority %d\n",
                    dest->nr,
                    dest->current_in_service->nr,
                    dest->current_in_service->vector, vector,
                    dest->current_in_service->priority));
    }
    else {
      dest->current_pending = NULL;
      vector = opic->spurious_vector;
      DTRACE(opic, ("interrupt ack %d - spurious interrupt %d\n",
                    dest->nr, vector));
    }
  }
  return vector;
}


static void
do_end_of_interrupt_register_N_write(device *me,
                                     hw_opic_device *opic,
                                     int dest_nr,
                                     unsigned reg)
{
  opic_interrupt_destination *dest = &opic->interrupt_destination[dest_nr];

  ASSERT(dest_nr >= 0 && dest_nr < opic->nr_interrupt_destinations);
  ASSERT(dest_nr == dest->nr);

  /* check the value written is zero */
  if (reg != 0) {
    DTRACE(opic, ("eoi %d - ignoring nonzero value\n", dest->nr));
  }

  /* user doing wierd things? */
  if (dest->current_in_service == NULL) {
    DTRACE(opic, ("eoi %d - strange, no current interrupt\n", dest->nr));
    return;
  }

  /* an internal stuff up? */
  if (!(dest->current_in_service->in_service & dest->bit)) {
    device_error(me, "eoi %d - current interrupt not in service", dest->nr);
  }

  /* find what was probably the previous in service interrupt */
  dest->current_in_service->in_service &= ~dest->bit;
  DTRACE(opic, ("eoi %d - ending %d - priority %d, vector %d\n",
                dest->nr,
                dest->current_in_service->nr,
                dest->current_in_service->priority,
                dest->current_in_service->vector));
  dest->current_in_service = find_interrupt_for_dest(me, opic, dest, in_service_interrupt);
  if (dest->current_in_service != NULL)
    DTRACE(opic, ("eoi %d - resuming %d - priority %d, vector %d\n",
                  dest->nr,
                  dest->current_in_service->nr,
                  dest->current_in_service->priority,
                  dest->current_in_service->vector));
  else
    DTRACE(opic, ("eoi %d - resuming none\n", dest->nr));

  /* check to see if that shouldn't be interrupted */
  dest->current_pending = find_interrupt_for_dest(me, opic, dest, pending_interrupt);
  if (can_deliver(me, dest->current_pending, dest)) {
    ASSERT(dest->current_pending->pending & dest->bit);
    assert_interrupt(me, opic, dest);
  }
  else {
    dest->current_pending = NULL;
  }
}


static void
decode_opic_address(device *me,
                    hw_opic_device *opic,
                    int space,
                    unsigned_word address,
                    unsigned nr_bytes,
                    opic_register *type,
                    int *index)
{
  int isb = 0;

  /* is the size valid? */
  if (nr_bytes != 4) {
    *type = invalid_opic_register;
    *index = -1;
    return;
  }

  /* try for a per-processor register within the interrupt delivery
     unit */
  if (space == opic->idu.space
      && address >= (opic->idu.address + idu_per_processor_register_base)
      && address < (opic->idu.address + idu_per_processor_register_base
                    + (sizeof_idu_per_processor_register_block
                       * opic->nr_interrupt_destinations))) {
    unsigned_word block_offset = (address
                                  - opic->idu.address
                                  - idu_per_processor_register_base);
    unsigned_word offset = block_offset % sizeof_idu_per_processor_register_block;
    *index = block_offset / sizeof_idu_per_processor_register_block;
    switch (offset) {
    case 0x040:
      *type = ipi_N_dispatch_register;
      *index = 0;
      break;
    case 0x050:
      *type = ipi_N_dispatch_register;
      *index = 1;
      break;
    case 0x060:
      *type = ipi_N_dispatch_register;
      *index = 2;
      break;
    case 0x070:
      *type = ipi_N_dispatch_register;
      *index = 3;
      break;
    case 0x080:
      *type = current_task_priority_register_N;
      break;
    case 0x0a0:
      *type = interrupt_acknowledge_register_N;
      break;
    case 0x0b0:
      *type = end_of_interrupt_register_N;
      break;
    default:
      *type = invalid_opic_register;
      break;
    }
    DTRACE(opic, ("per-processor register %d:0x%lx - %s[%d]\n",
                  space, (unsigned long)address,
                  opic_register_name(*type),
                  *index));
    return;
  }

  /* try for an interrupt source unit */
  for (isb = 0; isb < opic->nr_isu_blocks; isb++) {
    if (opic->isu_block[isb].space == space
        && address >= opic->isu_block[isb].address
        && address < (opic->isu_block[isb].address + opic->isu_block[isb].size)) {
      unsigned_word block_offset = address - opic->isu_block[isb].address;
      unsigned_word offset = block_offset % sizeof_isu_register_block;
      *index = (opic->isu_block[isb].int_number
                + (block_offset / sizeof_isu_register_block));
      switch (offset) {
      case 0x00:
        *type = interrupt_source_N_vector_priority_register;
        break;
      case 0x10:
        *type = interrupt_source_N_destination_register;
        break;
      default:
        *type = invalid_opic_register;
        break;
      }
      DTRACE(opic, ("isu register %d:0x%lx - %s[%d]\n",
                    space, (unsigned long)address,
                    opic_register_name(*type),
                    *index));
      return;
    }
  }

  /* try for a timer */
  if (space == opic->idu.space
      && address >= (opic->idu.address + idu_timer_base)
      && address < (opic->idu.address + idu_timer_base
                    + opic->nr_timer_interrupts * sizeof_timer_register_block)) {
    unsigned_word offset = address % sizeof_timer_register_block;
    *index = ((address - opic->idu.address - idu_timer_base)
              / sizeof_timer_register_block);
    switch (offset) {
    case 0x00:
      *type = timer_N_current_count_register;
      break;
    case 0x10:
      *type = timer_N_base_count_register;
      break;
    case 0x20:
      *type = timer_N_vector_priority_register;
      break;
    case 0x30:
      *type = timer_N_destination_register;
      break;
    default:
      *type = invalid_opic_register;
      break;
    }
    DTRACE(opic, ("timer register %d:0x%lx - %s[%d]\n",
                  space, (unsigned long)address,
                  opic_register_name(*type),
                  *index));
    return;
  }

  /* finally some other misc global register */
  if (space == opic->idu.space
      && address >= opic->idu.address
      && address < opic->idu.address + opic->idu.size) {
    unsigned_word block_offset = address - opic->idu.address;
    switch (block_offset) {
    case 0x010f0:
      *type = timer_frequency_reporting_register;
      *index = -1;
      break;
    case 0x010e0:
      *type = spurious_vector_register;
      *index = -1;
      break;
    case 0x010d0:
    case 0x010c0:
    case 0x010b0:
    case 0x010a0:
      *type = ipi_N_vector_priority_register;
      *index = (block_offset - 0x010a0) / 16;
      break;
    case 0x01090:
      *type = processor_init_register;
      *index = -1;
      break;
    case 0x01080:
      *type = vendor_identification_register;
      *index = -1;
      break;
    case 0x01020:
      *type = global_configuration_register_N;
      *index = 0;
      break;
    case 0x01000:
      *type = feature_reporting_register_N;
      *index = 0;
      break;
    default:
      *type = invalid_opic_register;
      *index = -1;
      break;
    }
    DTRACE(opic, ("global register %d:0x%lx - %s[%d]\n",
                  space, (unsigned long)address,
                  opic_register_name(*type),
                  *index));
    return;
  }

  /* nothing matched */
  *type = invalid_opic_register;
  DTRACE(opic, ("invalid register %d:0x%lx\n",
                space, (unsigned long)address));
  return;
}


/* Processor init register:

   The bits in this register (one per processor) are directly wired to
   output "init" interrupt ports. */

static unsigned
do_processor_init_register_read(device *me,
                                hw_opic_device *opic)
{
  unsigned reg = opic->init;
  DTRACE(opic, ("processor init register - read 0x%lx\n",
                (long)reg));
  return reg;
}

static void
do_processor_init_register_write(device *me,
                                 hw_opic_device *opic,
                                 unsigned reg)
{
  int i;
  for (i = 0; i < opic->nr_interrupt_destinations; i++) {
    opic_interrupt_destination *dest = &opic->interrupt_destination[i];
    if ((reg & dest->bit) != (opic->init & dest->bit)) {
      if (reg & dest->bit) {
        DTRACE(opic, ("processor init register - write 0x%lx - asserting init%d\n",
                      (long)reg, i));
        opic->init |= dest->bit;
        device_interrupt_event(me, dest->init_port, 1, NULL, 0);
      }
      else {
        DTRACE(opic, ("processor init register - write 0x%lx - negating init%d\n",
                      (long)reg, i));
        opic->init &= ~dest->bit;
        device_interrupt_event(me, dest->init_port, 0, NULL, 0);
      }
    }
  }
}



/* Interrupt Source Vector/Priority Register: */

static unsigned
read_vector_priority_register(device *me,
                              hw_opic_device *opic,
                              opic_interrupt_source *interrupt,
                              const char *reg_name,
                              int reg_index)
{
  unsigned reg;
  reg = 0;
  reg |= interrupt->is_masked;
  reg |= (interrupt->in_service || interrupt->pending
          ? isu_active_bit : 0); /* active */
  reg |= interrupt->is_multicast;
  reg |= interrupt->is_positive_polarity;
  reg |= interrupt->is_level_triggered; /* sense? */
  reg |= interrupt->priority << isu_priority_shift;
  reg |= interrupt->vector;
  DTRACE(opic, ("%s %d vector/priority register - read 0x%lx\n",
                reg_name, reg_index, (unsigned long)reg));
  return reg;
}

static unsigned
do_interrupt_source_N_vector_priority_register_read(device *me,
                                                    hw_opic_device *opic,
                                                    int index)
{
  unsigned reg;
  ASSERT(index < opic->nr_external_interrupts);
  reg = read_vector_priority_register(me, opic,
                                      &opic->interrupt_source[index],
                                      "interrupt source", index);
  return reg;
}

static void
write_vector_priority_register(device *me,
                               hw_opic_device *opic,
                               opic_interrupt_source *interrupt,
                               unsigned reg,
                               const char *reg_name,
                               int reg_index)
{
  interrupt->is_masked = (reg & isu_mask_bit);
  interrupt->is_multicast = (reg & isu_multicast_bit);
  interrupt->is_positive_polarity = (reg & isu_positive_polarity_bit);
  interrupt->is_level_triggered = (reg & isu_level_triggered_bit);
  interrupt->priority = ((reg >> isu_priority_shift)
                         % max_nr_task_priorities);
  interrupt->vector = (reg & isu_vector_bits);
  DTRACE(opic, ("%s %d vector/priority register - write 0x%lx - %s%s%s-polarity, %s-triggered, priority %ld vector %ld\n",
                reg_name,
                reg_index,
                (unsigned long)reg,
                interrupt->is_masked ? "masked, " : "",
                interrupt->is_multicast ? "multicast, " : "",
                interrupt->is_positive_polarity ? "positive" : "negative",
                interrupt->is_level_triggered ? "level" : "edge",
                (long)interrupt->priority,
                (long)interrupt->vector));
}

static void
do_interrupt_source_N_vector_priority_register_write(device *me,
                                                     hw_opic_device *opic,
                                                     int index,
                                                     unsigned reg)
{
  ASSERT(index < opic->nr_external_interrupts);
  reg &= ~isu_multicast_bit; /* disable multicast */
  write_vector_priority_register(me, opic,
                                 &opic->interrupt_source[index],
                                 reg, "interrupt source", index);
}



/* Interrupt Source Destination Register: */

static unsigned
read_destination_register(device *me,
                          hw_opic_device *opic,
                          opic_interrupt_source *interrupt,
                          const char *reg_name,
                          int reg_index)
{
  unsigned long reg;
  reg = interrupt->destination;
  DTRACE(opic, ("%s %d destination register - read 0x%lx\n",
                reg_name, reg_index, reg));
  return reg;
}
                             
static unsigned
do_interrupt_source_N_destination_register_read(device *me,
                                                hw_opic_device *opic,
                                                int index)
{
  unsigned reg;
  ASSERT(index < opic->nr_external_interrupts);
  reg = read_destination_register(me, opic, &opic->external_interrupt_source[index],
                                  "interrupt source", index);
  return reg;
}

static void
write_destination_register(device *me,
                           hw_opic_device *opic,
                           opic_interrupt_source *interrupt,
                           unsigned reg,
                           const char *reg_name,
                           int reg_index)
{
  reg &= (1 << opic->nr_interrupt_destinations) - 1; /* mask out invalid */
  DTRACE(opic, ("%s %d destination register - write 0x%x\n",
                reg_name, reg_index, reg));
  interrupt->destination = reg;
}

static void
do_interrupt_source_N_destination_register_write(device *me,
                                                 hw_opic_device *opic,
                                                 int index,
                                                 unsigned reg)
{
  ASSERT(index < opic->nr_external_interrupts);
  write_destination_register(me, opic, &opic->external_interrupt_source[index],
                             reg, "interrupt source", index);
}



/* Spurious vector register: */

static unsigned
do_spurious_vector_register_read(device *me,
                                 hw_opic_device *opic)
{
  unsigned long reg = opic->spurious_vector;
  DTRACE(opic, ("spurious vector register - read 0x%lx\n", reg));
  return reg;
}

static void
do_spurious_vector_register_write(device *me,
                                  hw_opic_device *opic,
                                  unsigned reg)
{
  reg &= 0xff; /* mask off invalid */
  DTRACE(opic, ("spurious vector register - write 0x%x\n", reg));
  opic->spurious_vector = reg;
}



/* current task priority register: */

static unsigned
do_current_task_priority_register_N_read(device *me,
                                         hw_opic_device *opic,
                                         int index)
{
  opic_interrupt_destination *interrupt_destination = &opic->interrupt_destination[index];
  unsigned reg;
  ASSERT(index >= 0 && index < opic->nr_interrupt_destinations);
  reg = interrupt_destination->base_priority;
  DTRACE(opic, ("current task priority register %d - read 0x%x\n", index, reg));
  return reg;
}

static void
do_current_task_priority_register_N_write(device *me,
                                          hw_opic_device *opic,
                                          int index,
                                          unsigned reg)
{
  opic_interrupt_destination *interrupt_destination = &opic->interrupt_destination[index];
  ASSERT(index >= 0 && index < opic->nr_interrupt_destinations);
  reg %= max_nr_task_priorities;
  DTRACE(opic, ("current task priority register %d - write 0x%x\n", index, reg));
  interrupt_destination->base_priority = reg;
}



/* Timer Frequency Reporting Register: */

static unsigned
do_timer_frequency_reporting_register_read(device *me,
                                           hw_opic_device *opic)
{
  unsigned reg;
  reg = opic->timer_frequency;
  DTRACE(opic, ("timer frequency reporting register - read 0x%x\n", reg));
  return reg;
}

static void
do_timer_frequency_reporting_register_write(device *me,
                                            hw_opic_device *opic,
                                            unsigned reg)
{
  DTRACE(opic, ("timer frequency reporting register - write 0x%x\n", reg));
  opic->timer_frequency = reg;
}


/* timer registers: */

static unsigned
do_timer_N_current_count_register_read(device *me,
                                       hw_opic_device *opic,
                                       int index)
{
  opic_timer *timer = &opic->timer[index];
  unsigned reg;
  ASSERT(index >= 0 && index < opic->nr_timer_interrupts);
  if (timer->inhibited)
    reg = timer->count; /* stalled value */
  else
    reg = timer->count - device_event_queue_time(me); /* time remaining */
  DTRACE(opic, ("timer %d current count register - read 0x%x\n", index, reg));
  return reg;
}


static unsigned
do_timer_N_base_count_register_read(device *me,
                                    hw_opic_device *opic,
                                    int index)
{
  opic_timer *timer = &opic->timer[index];
  unsigned reg;
  ASSERT(index >= 0 && index < opic->nr_timer_interrupts);
  reg = timer->base_count;
  DTRACE(opic, ("timer %d base count register - read 0x%x\n", index, reg));
  return reg;
}


static void
timer_event(void *data)
{
  opic_timer *timer = data;
  device *me = timer->me;
  if (timer->inhibited)
    device_error(timer->me, "internal-error - timer event occured when timer %d inhibited",
                 timer->nr);
  handle_interrupt(timer->me, timer->opic, timer->interrupt_source, 1);
  timer->timeout_event = device_event_queue_schedule(me, timer->base_count,
                                                     timer_event, timer);
  DTRACE(opic, ("timer %d - interrupt at %ld, next at %d\n",
                timer->nr, (long)device_event_queue_time(me), timer->base_count));
}


static void
do_timer_N_base_count_register_write(device *me,
                                     hw_opic_device *opic,
                                     int index,
                                     unsigned reg)
{
  opic_timer *timer = &opic->timer[index];
  int inhibit;
  ASSERT(index >= 0 && index < opic->nr_timer_interrupts);
  inhibit = reg & 0x80000000;
  if (timer->inhibited && !inhibit) {
    timer->inhibited = 0;
    if (timer->timeout_event != NULL)
      device_event_queue_deschedule(me, timer->timeout_event);
    timer->count = device_event_queue_time(me) + reg;
    timer->base_count = reg;
    timer->timeout_event = device_event_queue_schedule(me, timer->base_count,
                                                       timer_event, (void*)timer);
    DTRACE(opic, ("timer %d base count register - write 0x%x - timer started\n",
                  index, reg));
  }
  else if (!timer->inhibited && inhibit) {
    if (timer->timeout_event != NULL)
      device_event_queue_deschedule(me, timer->timeout_event);
    timer->count = timer->count - device_event_queue_time(me);
    timer->inhibited = 1;
    timer->base_count = reg;
    DTRACE(opic, ("timer %d base count register - write 0x%x - timer stopped\n",
                  index, reg));
  }
  else {
    ASSERT((timer->inhibited && inhibit) || (!timer->inhibited && !inhibit));
    DTRACE(opic, ("timer %d base count register - write 0x%x\n", index, reg));
    timer->base_count = reg;
  }
}


static unsigned
do_timer_N_vector_priority_register_read(device *me,
                                         hw_opic_device *opic,
                                         int index)
{
  unsigned reg;
  ASSERT(index >= 0 && index < opic->nr_timer_interrupts);
  reg = read_vector_priority_register(me, opic,
                                      &opic->timer_interrupt_source[index],
                                      "timer", index);
  return reg;
}

static void
do_timer_N_vector_priority_register_write(device *me,
                                          hw_opic_device *opic,
                                          int index,
                                          unsigned reg)
{
  ASSERT(index >= 0 && index < opic->nr_timer_interrupts);
  reg &= ~isu_level_triggered_bit; /* force edge trigger */
  reg |= isu_positive_polarity_bit; /* force rising (positive) edge */
  reg |= isu_multicast_bit; /* force multicast */
  write_vector_priority_register(me, opic,
                                 &opic->timer_interrupt_source[index],
                                 reg, "timer", index);
}


static unsigned
do_timer_N_destination_register_read(device *me,
                                     hw_opic_device *opic,
                                     int index)
{
  unsigned reg;
  ASSERT(index >= 0 && index < opic->nr_timer_interrupts);
  reg = read_destination_register(me, opic, &opic->timer_interrupt_source[index],
                                  "timer", index);
  return reg;
}

static void
do_timer_N_destination_register_write(device *me,
                                      hw_opic_device *opic,
                                      int index,
                                      unsigned reg)
{
  ASSERT(index >= 0 && index < opic->nr_timer_interrupts);
  write_destination_register(me, opic, &opic->timer_interrupt_source[index],
                             reg, "timer", index);
}


/* IPI registers */

static unsigned
do_ipi_N_vector_priority_register_read(device *me,
                                       hw_opic_device *opic,
                                       int index)
{
  unsigned reg;
  ASSERT(index >= 0 && index < opic->nr_interprocessor_interrupts);
  reg = read_vector_priority_register(me, opic,
                                      &opic->interprocessor_interrupt_source[index],
                                      "ipi", index);
  return reg;
}

static void
do_ipi_N_vector_priority_register_write(device *me,
                                        hw_opic_device *opic,
                                        int index,
                                        unsigned reg)
{
  ASSERT(index >= 0 && index < opic->nr_interprocessor_interrupts);
  reg &= ~isu_level_triggered_bit; /* force edge trigger */
  reg |= isu_positive_polarity_bit; /* force rising (positive) edge */
  reg |= isu_multicast_bit; /* force a multicast source */
  write_vector_priority_register(me, opic,
                                 &opic->interprocessor_interrupt_source[index],
                                 reg, "ipi", index);
}

static void
do_ipi_N_dispatch_register_write(device *me,
                                 hw_opic_device *opic,
                                 int index,
                                 unsigned reg)
{
  opic_interrupt_source *source = &opic->interprocessor_interrupt_source[index];
  ASSERT(index >= 0 && index < opic->nr_interprocessor_interrupts);
  DTRACE(opic, ("ipi %d interrupt dispatch register - write 0x%x\n", index, reg));
  source->destination = reg;
  handle_interrupt(me, opic, source, 1);
}


/* vendor and other global registers */

static unsigned
do_vendor_identification_register_read(device *me,
                                       hw_opic_device *opic)
{
  unsigned reg;
  reg = opic->vendor_identification;
  DTRACE(opic, ("vendor identification register - read 0x%x\n", reg));
  return reg;
}

static unsigned
do_feature_reporting_register_N_read(device *me,
                                     hw_opic_device *opic,
                                     int index)
{
  unsigned reg = 0;
  ASSERT(index == 0);
  switch (index) {
  case 0:
    reg |= (opic->nr_external_interrupts << 16);
    reg |= (opic->nr_interrupt_destinations << 8);
    reg |= (2/*version 1.2*/);
    break;
  }
  DTRACE(opic, ("feature reporting register %d - read 0x%x\n", index, reg));
  return reg;
}

static unsigned
do_global_configuration_register_N_read(device *me,
                                        hw_opic_device *opic,
                                        int index)
{
  unsigned reg = 0;
  ASSERT(index == 0);
  switch (index) {
  case 0:
    reg |= gcr0_8259_bit; /* hardwire 8259 disabled */
    break;
  }
  DTRACE(opic, ("global configuration register %d - read 0x%x\n", index, reg));
  return reg;
}

static void
do_global_configuration_register_N_write(device *me,
                                         hw_opic_device *opic,
                                         int index,
                                         unsigned reg)
{
  ASSERT(index == 0);
  if (reg & gcr0_reset_bit) {
    DTRACE(opic, ("global configuration register %d - write 0x%x - reseting opic\n", index, reg));
    hw_opic_init_data(me);
  }
  if (!(reg & gcr0_8259_bit)) {
    DTRACE(opic, ("global configuration register %d - write 0x%x - ignoring 8259 enable\n", index, reg));
  }
}



/* register read-write */

static unsigned
hw_opic_io_read_buffer(device *me,
                       void *dest,
                       int space,
                       unsigned_word addr,
                       unsigned nr_bytes,
                       cpu *processor,
                       unsigned_word cia)
{
  hw_opic_device *opic = (hw_opic_device*)device_data(me);
  opic_register type;
  int index;
  decode_opic_address(me, opic, space, addr, nr_bytes, &type, &index);
  if (type == invalid_opic_register) {
    device_error(me, "invalid opic read access to %d:0x%lx (%d bytes)",
                 space, (unsigned long)addr, nr_bytes);
  }
  else {
    unsigned reg;
    switch (type) {
    case processor_init_register:
      reg = do_processor_init_register_read(me, opic);
      break;
    case interrupt_source_N_vector_priority_register:
      reg = do_interrupt_source_N_vector_priority_register_read(me, opic, index);
      break;
    case interrupt_source_N_destination_register:
      reg = do_interrupt_source_N_destination_register_read(me, opic, index);
      break;
    case interrupt_acknowledge_register_N:
      reg = do_interrupt_acknowledge_register_N_read(me, opic, index);
      break;
    case spurious_vector_register:
      reg = do_spurious_vector_register_read(me, opic);
      break;
    case current_task_priority_register_N:
      reg = do_current_task_priority_register_N_read(me, opic, index);
      break;
    case timer_frequency_reporting_register:
      reg = do_timer_frequency_reporting_register_read(me, opic);
      break;
    case timer_N_current_count_register:
      reg = do_timer_N_current_count_register_read(me, opic, index);
      break;
    case timer_N_base_count_register:
      reg = do_timer_N_base_count_register_read(me, opic, index);
      break;
    case timer_N_vector_priority_register:
      reg = do_timer_N_vector_priority_register_read(me, opic, index);
      break;
    case timer_N_destination_register:
      reg = do_timer_N_destination_register_read(me, opic, index);
      break;
    case ipi_N_vector_priority_register:
      reg = do_ipi_N_vector_priority_register_read(me, opic, index);
      break;
    case feature_reporting_register_N:
      reg = do_feature_reporting_register_N_read(me, opic, index);
      break;
    case global_configuration_register_N:
      reg = do_global_configuration_register_N_read(me, opic, index);
      break;
    case vendor_identification_register:
      reg = do_vendor_identification_register_read(me, opic);
      break;
    default:
      reg = 0;
      device_error(me, "unimplemented read of register %s[%d]",
                   opic_register_name(type), index);
    }
    *(unsigned_4*)dest = H2LE_4(reg);
  }
  return nr_bytes;
}


static unsigned
hw_opic_io_write_buffer(device *me,
                        const void *source,
                        int space,
                        unsigned_word addr,
                        unsigned nr_bytes,
                        cpu *processor,
                        unsigned_word cia)
{
  hw_opic_device *opic = (hw_opic_device*)device_data(me);
  opic_register type;
  int index;
  decode_opic_address(me, opic, space, addr, nr_bytes, &type, &index);
  if (type == invalid_opic_register) {
    device_error(me, "invalid opic write access to %d:0x%lx (%d bytes)",
                 space, (unsigned long)addr, nr_bytes);
  }
  else {
    unsigned reg = LE2H_4(*(unsigned_4*)source);
    switch (type) {
    case processor_init_register:
      do_processor_init_register_write(me, opic, reg);
      break;
    case interrupt_source_N_vector_priority_register:
      do_interrupt_source_N_vector_priority_register_write(me, opic, index, reg);
      break;
    case interrupt_source_N_destination_register:
      do_interrupt_source_N_destination_register_write(me, opic, index, reg);
      break;
    case end_of_interrupt_register_N:
      do_end_of_interrupt_register_N_write(me, opic, index, reg);
      break;
    case spurious_vector_register:
      do_spurious_vector_register_write(me, opic, reg);
      break;
    case current_task_priority_register_N:
      do_current_task_priority_register_N_write(me, opic, index, reg);
      break;
    case timer_frequency_reporting_register:
      do_timer_frequency_reporting_register_write(me, opic, reg);
      break;
    case timer_N_base_count_register:
      do_timer_N_base_count_register_write(me, opic, index, reg);
      break;
    case timer_N_vector_priority_register:
      do_timer_N_vector_priority_register_write(me, opic, index, reg);
      break;
    case timer_N_destination_register:
      do_timer_N_destination_register_write(me, opic, index, reg);
      break;
    case ipi_N_dispatch_register:
      do_ipi_N_dispatch_register_write(me, opic, index, reg);
      break;
    case ipi_N_vector_priority_register:
      do_ipi_N_vector_priority_register_write(me, opic, index, reg);
      break;
    case global_configuration_register_N:
      do_global_configuration_register_N_write(me, opic, index, reg);
      break;
    default:
      device_error(me, "unimplemented write to register %s[%d]",
                   opic_register_name(type), index);
    }
  }
  return nr_bytes;
}
  
  
static void
hw_opic_interrupt_event(device *me,
                        int my_port,
                        device *source,
                        int source_port,
                        int level,
                        cpu *processor,
                        unsigned_word cia)
{
  hw_opic_device *opic = (hw_opic_device*)device_data(me);

  int isb;
  int src_nr = 0;

  /* find the corresponding internal input port */
  for (isb = 0; isb < opic->nr_isu_blocks; isb++) {
    if (my_port >= opic->isu_block[isb].int_number
        && my_port < opic->isu_block[isb].int_number + opic->isu_block[isb].range) {
      src_nr += my_port - opic->isu_block[isb].int_number;
      break;
    }
    else
      src_nr += opic->isu_block[isb].range;
  }
  if (isb == opic->nr_isu_blocks)
    device_error(me, "interrupt %d out of range", my_port);
  DTRACE(opic, ("external-interrupt %d, internal %d, level %d\n",
                my_port, src_nr, level));

  /* pass it on */
  ASSERT(src_nr >= 0 && src_nr < opic->nr_external_interrupts);
  handle_interrupt(me, opic, &opic->external_interrupt_source[src_nr], level);
}


static const device_interrupt_port_descriptor hw_opic_interrupt_ports[] = {
  { "irq", 0, max_nr_interrupt_sources, input_port, },
  { "intr", 0, max_nr_interrupt_destinations, output_port, },
  { "init", max_nr_interrupt_destinations, max_nr_interrupt_destinations, output_port, },
  { NULL }
};


static device_callbacks const hw_opic_callbacks = {
  { generic_device_init_address,
    hw_opic_init_data },
  { NULL, }, /* address */
  { hw_opic_io_read_buffer,
    hw_opic_io_write_buffer }, /* IO */
  { NULL, }, /* DMA */
  { hw_opic_interrupt_event, NULL, hw_opic_interrupt_ports }, /* interrupt */
  { NULL, }, /* unit */
  NULL, /* instance */
};

static void *
hw_opic_create(const char *name,
               const device_unit *unit_address,
               const char *args)
{
  hw_opic_device *opic = ZALLOC(hw_opic_device);
  return opic;
}



const device_descriptor hw_opic_device_descriptor[] = {
  { "opic", hw_opic_create, &hw_opic_callbacks },
  { NULL },
};

#endif /* _HW_OPIC_C_ */