dv-mn103int.c

这个是LINUX下的GDB调度工具的源码

/*  This file is part of the program GDB, the GNU debugger.
    
    Copyright (C) 1998 Free Software Foundation, Inc.
    Contributed by Cygnus Solutions.
    
    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.
    
    */


#include "sim-main.h"
#include "hw-main.h"
#include "sim-hw.h"

/* DEVICE

   
   mn103int - mn103002 interrupt controller

   
   DESCRIPTION

   
   Implements the mn103002 interrupt controller described in the
   mn103002 user guide.


   PROPERTIES
   

   reg = <icr-adr> <icr-siz> <iagr-adr> <iadr-siz> <extmd-adr> <extmd-siz>

   Specify the address of the ICR (total of 30 registers), IAGR and
   EXTMD registers (within the parent bus).

   The reg property value `0x34000100 0x7C 0x34000200 0x8 0x3400280
   0x8' locates the interrupt controller at the addresses specified in
   the mn103002 interrupt controller user guide.


   PORTS


   nmi (output)

   Non-maskable interrupt output port.  An event on this output ports
   indicates a NMI request from the interrupt controller.  The value
   attached to the event should be ignored.


   level (output)

   Maskable interrupt level output port.  An event on this output port
   indicates a maskable interrupt request at the specified level.  The
   event value defines the level being requested.

   The interrupt controller will generate an event on this port
   whenever there is a change to the internal state of the interrupt
   controller.


   ack (input)

   Signal from processor indicating that a maskable interrupt has been
   accepted and the interrupt controller should latch the IAGR with
   value of the current highest priority interrupting group.

   The event value is the interrupt level being accepted by the
   processor.  It should be consistent with the most recent LEVEL sent
   to the processor from the interrupt controller.


   int[0..100] (input)

   Level or edge triggered interrupt input port.  Each of the 30
   groups (0..30) can have up to 4 (0..3) interrupt inputs.  The
   interpretation of a port event/value is determined by the
   configuration of the corresponding interrupt group.

   For convenience, numerous aliases to these interrupt inputs are
   provided.


   BUGS


   For edge triggered interrupts, the interrupt controller does not
   differentiate between POSITIVE (rising) and NEGATIVE (falling)
   edges.  Instead any input port event is considered to be an
   interrupt trigger.

   For level sensitive interrupts, the interrupt controller ignores
   active HIGH/LOW settings and instead always interprets a nonzero
   port value as an interrupt assertion and a zero port value as a
   negation.

   */


/* The interrupt groups - numbered according to mn103002 convention */

enum mn103int_trigger {
  ACTIVE_LOW,
  ACTIVE_HIGH,
  POSITIVE_EDGE,
  NEGATIVE_EDGE,
};

enum mn103int_type {
  NMI_GROUP,
  LEVEL_GROUP,
};

struct mn103int_group {
  int gid;
  int level;
  unsigned enable;
  unsigned request;
  unsigned input;
  enum mn103int_trigger trigger;
  enum mn103int_type type;
};

enum {
  FIRST_NMI_GROUP = 0,
  LAST_NMI_GROUP = 1,
  FIRST_LEVEL_GROUP = 2,
  LAST_LEVEL_GROUP = 30,
  NR_GROUPS,
};

enum {
  LOWEST_LEVEL = 7,
};

/* The interrupt controller register address blocks */

struct mn103int_block {
  unsigned_word base;
  unsigned_word bound;
};

enum { ICR_BLOCK, IAGR_BLOCK, EXTMD_BLOCK, NR_BLOCKS };


struct mn103int {
  struct mn103int_block block[NR_BLOCKS];
  struct mn103int_group group[NR_GROUPS];
  unsigned interrupt_accepted_group;
};



/* output port ID's */ 

enum {
  NMI_PORT,
  LEVEL_PORT,
};


/* input port ID's */

enum {
  G0_PORT = 0,
  G1_PORT = 4,
  G2_PORT = 8,
  G3_PORT = 12,
  G4_PORT = 16,
  G5_PORT = 20,
  G6_PORT = 24,
  G7_PORT = 28,
  G8_PORT = 32,
  G9_PORT = 36,
  G10_PORT = 40,
  G11_PORT = 44,
  G12_PORT = 48,
  G13_PORT = 52,
  G14_PORT = 56,
  G15_PORT = 60,
  G16_PORT = 64,
  G17_PORT = 68,
  G18_PORT = 72,
  G19_PORT = 76,
  G20_PORT = 80,
  G21_PORT = 84,
  G22_PORT = 88,
  G23_PORT = 92,
  IRQ0_PORT = G23_PORT,
  G24_PORT = 96,
  G25_PORT = 100,
  G26_PORT = 104,
  G27_PORT = 108,
  IRQ4_PORT = G27_PORT,
  G28_PORT = 112,
  G29_PORT = 116,
  G30_PORT = 120,
  NR_G_PORTS = 124,
  ACK_PORT,
};

static const struct hw_port_descriptor mn103int_ports[] = {

  /* interrupt outputs */

  { "nmi", NMI_PORT, 0, output_port, },
  { "level", LEVEL_PORT, 0, output_port, },

  /* interrupt ack (latch) input from cpu */

  { "ack", ACK_PORT, 0, input_port, },

  /* interrupt inputs (as names) */

  { "nmirq", G0_PORT + 0, 0, input_port, },
  { "watchdog", G0_PORT + 1, 0, input_port, },
  { "syserr", G0_PORT + 2, 0, input_port, },

  { "timer-0-underflow", G2_PORT, 0, input_port, },
  { "timer-1-underflow", G3_PORT, 0, input_port, },
  { "timer-2-underflow", G4_PORT, 0, input_port, },
  { "timer-3-underflow", G5_PORT, 0, input_port, },
  { "timer-4-underflow", G6_PORT, 0, input_port, },
  { "timer-5-underflow", G7_PORT, 0, input_port, },
  { "timer-6-underflow", G8_PORT, 0, input_port, },

  { "timer-6-compare-a", G9_PORT, 0, input_port, },
  { "timer-6-compare-b", G10_PORT, 0, input_port, },

  { "dma-0-end", G12_PORT, 0, input_port, },
  { "dma-1-end", G13_PORT, 0, input_port, },
  { "dma-2-end", G14_PORT, 0, input_port, },
  { "dma-3-end", G15_PORT, 0, input_port, },

  { "serial-0-receive",  G16_PORT, 0, input_port, },
  { "serial-0-transmit", G17_PORT, 0, input_port, },

  { "serial-1-receive",  G18_PORT, 0, input_port, },
  { "serial-1-transmit", G19_PORT, 0, input_port, },

  { "serial-2-receive",  G20_PORT, 0, input_port, },
  { "serial-2-transmit", G21_PORT, 0, input_port, },

  { "irq-0", G23_PORT, 0, input_port, },
  { "irq-1", G24_PORT, 0, input_port, },
  { "irq-2", G25_PORT, 0, input_port, },
  { "irq-3", G26_PORT, 0, input_port, },
  { "irq-4", G27_PORT, 0, input_port, },
  { "irq-5", G28_PORT, 0, input_port, },
  { "irq-6", G29_PORT, 0, input_port, },
  { "irq-7", G30_PORT, 0, input_port, },

  /* interrupt inputs (as generic numbers) */

  { "int", 0, NR_G_PORTS, input_port, },

  { NULL, },
};


/* Macros for extracting/restoring the various register bits */

#define EXTRACT_ID(X) (LSEXTRACTED8 ((X), 3, 0))
#define INSERT_ID(X) (LSINSERTED8 ((X), 3, 0))

#define EXTRACT_IR(X) (LSEXTRACTED8 ((X), 7, 4))
#define INSERT_IR(X) (LSINSERTED8 ((X), 7, 4))

#define EXTRACT_IE(X) (LSEXTRACTED8 ((X), 3, 0))
#define INSERT_IE(X) (LSINSERTED8 ((X), 3, 0))

#define EXTRACT_LV(X) (LSEXTRACTED8 ((X), 6, 4))
#define INSERT_LV(X) (LSINSERTED8 ((X), 6, 4))



/* Finish off the partially created hw device.  Attach our local
   callbacks.  Wire up our port names etc */

static hw_io_read_buffer_method mn103int_io_read_buffer;
static hw_io_write_buffer_method mn103int_io_write_buffer;
static hw_port_event_method mn103int_port_event;
static hw_ioctl_method mn103int_ioctl;



static void
attach_mn103int_regs (struct hw *me,
		      struct mn103int *controller)
{
  int i;
  if (hw_find_property (me, "reg") == NULL)
    hw_abort (me, "Missing \"reg\" property");
  for (i = 0; i < NR_BLOCKS; i++)
    {
      unsigned_word attach_address;
      int attach_space;
      unsigned attach_size;
      reg_property_spec reg;
      if (!hw_find_reg_array_property (me, "reg", i, &reg))
	hw_abort (me, "\"reg\" property must contain three addr/size entries");
      hw_unit_address_to_attach_address (hw_parent (me),
					 &reg.address,
					 &attach_space,
					 &attach_address,
					 me);
      controller->block[i].base = attach_address;
      hw_unit_size_to_attach_size (hw_parent (me),
				   &reg.size,
				   &attach_size, me);
      controller->block[i].bound = attach_address + (attach_size - 1);
      hw_attach_address (hw_parent (me),
			 0,
			 attach_space, attach_address, attach_size,
			 me);
    }
}

static void
mn103int_finish (struct hw *me)
{
  int gid;
  struct mn103int *controller;

  controller = HW_ZALLOC (me, struct mn103int);
  set_hw_data (me, controller);
  set_hw_io_read_buffer (me, mn103int_io_read_buffer);
  set_hw_io_write_buffer (me, mn103int_io_write_buffer);
  set_hw_ports (me, mn103int_ports);
  set_hw_port_event (me, mn103int_port_event);
  me->to_ioctl = mn103int_ioctl;

  /* Attach ourself to our parent bus */
  attach_mn103int_regs (me, controller);

  /* Initialize all the groups according to their default configuration */
  for (gid = 0; gid < NR_GROUPS; gid++)
    {
      struct mn103int_group *group = &controller->group[gid];
      group->trigger = NEGATIVE_EDGE;
      group->gid = gid;
      if (FIRST_NMI_GROUP <= gid && gid <= LAST_NMI_GROUP)
	{
	  group->enable = 0xf;
	  group->type = NMI_GROUP;
	}
      else if (FIRST_LEVEL_GROUP <= gid && gid <= LAST_LEVEL_GROUP)
	{
	  group->enable = 0x0;
	  group->type = LEVEL_GROUP;
	}
      else
	hw_abort (me, "internal error - unknown group id");
    }
}



/* Perform the nasty work of figuring out which of the interrupt
   groups should have its interrupt delivered. */

static int
find_highest_interrupt_group (struct hw *me,
			      struct mn103int *controller)
{
  int gid;
  int selected;

  /* FIRST_NMI_GROUP (group zero) is used as a special default value
     when searching for an interrupt group.*/
  selected = FIRST_NMI_GROUP; 
  controller->group[FIRST_NMI_GROUP].level = 7;
  
  for (gid = FIRST_LEVEL_GROUP; gid <= LAST_LEVEL_GROUP; gid++)
    {
      struct mn103int_group *group = &controller->group[gid];
      if ((group->request & group->enable) != 0)
	{
	  /* Remember, lower level, higher priority.  */
	  if (group->level < controller->group[selected].level)
	    {
	      selected = gid;
	    }
	}
    }
  return selected;
}


/* Notify the processor of an interrupt level update */

static void
push_interrupt_level (struct hw *me,
		      struct mn103int *controller)
{
  int selected = find_highest_interrupt_group (me, controller);
  int level = controller->group[selected].level;
  HW_TRACE ((me, "port-out - selected=%d level=%d", selected, level));
  hw_port_event (me, LEVEL_PORT, level);
}


/* An event arrives on an interrupt port */