| /* 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, ®)) | |
| 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), ®.address, | |
| &opic->isu_block[isb].space, | |
| &opic->isu_block[isb].address, | |
| me) | |
| || !device_size_to_attach_size(device_parent(me), ®.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_ */ |