| /* hp3000_clk.c: HP 3000 30135A System Clock/Fault Logging Interface simulator | |
| Copyright (c) 2016, J. David Bryan | |
| Permission is hereby granted, free of charge, to any person obtaining a copy | |
| of this software and associated documentation files (the "Software"), to deal | |
| in the Software without restriction, including without limitation the rights | |
| to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
| copies of the Software, and to permit persons to whom the Software is | |
| furnished to do so, subject to the following conditions: | |
| The above copyright notice and this permission notice shall be included in | |
| all copies or substantial portions of the Software. | |
| THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
| IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
| FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
| AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | |
| ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | |
| WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | |
| Except as contained in this notice, the name of the author shall not be used | |
| in advertising or otherwise to promote the sale, use or other dealings in | |
| this Software without prior written authorization from the author. | |
| CLK HP 30135A System Clock/Fault Logging Interface | |
| 12-Sep-16 JDB Changed DIB register macro usage from SRDATA to DIB_REG | |
| 11-Jul-16 JDB Change "clk_unit" from a UNIT to an array of one UNIT | |
| 08-Jul-16 JDB Added REG entry to save the unit wait field | |
| 09-Jun-16 JDB Clarified the IRQ FF set code in DRESETINT | |
| 08-Jun-16 JDB Corrected %d format to %u for unsigned values | |
| 21-Mar-16 JDB Changed inbound_value and outbound_value types to HP_WORD | |
| 08-Jun-15 JDB First release version | |
| 12-Aug-14 JDB Passed the system clock diagnostic (D426A) | |
| 05-Jul-14 JDB Created | |
| References: | |
| - Stand-Alone System Clock Diagnostic | |
| (32230-90005, January 1979) | |
| - HP 3000 Series III Engineering Diagrams Set | |
| (30000-90141, April 1980) | |
| The HP 30135A System Clock/Fault Logging Interface is used with Series II and | |
| III systems and provides two devices on a single I/O card: a programmable | |
| interval clock employed as the MPE system clock and an interface to the ECC | |
| fault logging RAMs on the semiconductor main memory arrays. This replaced | |
| the earlier 30031A System Clock/Console Interface that had been used with the | |
| CX and Series I machines, which used core memory. As part of this change, | |
| the system console moved from the dedicated card to ATC port 0. | |
| The clock provides programmable periods of 10 microseconds to 10 seconds in | |
| decade increments. Each "tick" of the clock increments a presettable counter | |
| that may be compared to a selected limit value. The clock may request an | |
| interrupt when the values are equal, and a status indication is provided if | |
| the counter reaches the limit a second time without acknowledgement. | |
| The clock simulation provides both a REALTIME mode that establishes periods | |
| in terms of event intervals, based on an average instruction time of 2.5 | |
| microseconds, and a CALTIME mode that calibrates the time delays to match | |
| wall-clock time. As an example, in the former mode, a 1 millisecond period | |
| will elapse after 400 instructions are executed, whereas in the latter mode, | |
| the same period will elapse after 1 millisecond of wall-clock time. As the | |
| simulator is generally one or two orders of magnitude faster than a real HP | |
| 3000, the real-time mode will satisfy the expectations of software that times | |
| external events, such as a disc seek, via a delay loop, whereas the | |
| calibrated mode will update a time-of-day clock as expected by users of the | |
| system. In practice, this means that setting REALTIME mode is necessary to | |
| satisfy the hardware diagnostics, and setting CALTIME mode is necessary when | |
| running MPE. | |
| Currently, the Fault Logging Interface simulator is not implemented. This | |
| interface is accessed via DRT 2 by the MPE memory logging process, MEMLOGP, | |
| but the process is smart enough to terminate if DRT 2 does not respond. As | |
| the simulator relies on a host memory array to simulate RAM and does not | |
| simulate the ECC check bits, an FLI implementation would always return a "no | |
| errors detected" condition. | |
| The clock interface responds only to direct I/O instructions, as follows: | |
| Control Word Format (CIO): | |
| 0 | 1 2 3 | 4 5 6 | 7 8 9 |10 11 12 |13 14 15 | |
| +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ | |
| | M / rate | E | - | irq reset | C | L | A | - - - - | I | | |
| +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ | |
| Where: | |
| M = master reset (if bit 3 = 0) | |
| E = master reset enable/load count rate (0/1) | |
| C = reset count register after LR=CR interrupt | |
| L = a WIO addresses the limit/count (0/1) register | |
| A = reset all interrupts | |
| I = enable clock interrupts | |
| Count Rate Selection: | |
| 000 = unused | |
| 001 = 10 microseconds | |
| 010 = 100 microseconds | |
| 011 = 1 millisecond | |
| 100 = 10 milliseconds | |
| 101 = 100 milliseconds | |
| 110 = 1 second | |
| 111 = 10 seconds | |
| IRQ Reset: | |
| 000 = none | |
| 001 = clear LR = CR interrupt | |
| 010 = clear LR = CR overflow interrupt | |
| 011 = clear I/O system interrupt (SIN) | |
| 100 = unused | |
| 101 = unused | |
| 110 = unused | |
| 111 = unused | |
| Status Word Format (TIO): | |
| 0 | 1 2 3 | 4 5 6 | 7 8 9 |10 11 12 |13 14 15 | |
| +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ | |
| | S | D | rate | - - - - - | C | F | - | I | L | R | | |
| +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ | |
| Where: | |
| S = SIO OK (always 0) | |
| D = direct read/write I/O OK (always 1) | |
| C = limit register = count register | |
| F = limit register = count register overflow (lost tick) | |
| I = I/O system interrupt request (SIN) | |
| L = limit/count (0/1) register selected | |
| R = reset count register after interrupt | |
| Output Data Word Format (WIO): | |
| 0 | 1 2 3 | 4 5 6 | 7 8 9 |10 11 12 |13 14 15 | |
| +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ | |
| | limit register value/count register reset | | |
| +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ | |
| If control word bit 9 is 0, the value is written to the limit register. If | |
| control word bit 9 is 1, the count register is cleared to zero; the output | |
| value is ignored. | |
| Input Data Word Format (RIO): | |
| 0 | 1 2 3 | 4 5 6 | 7 8 9 |10 11 12 |13 14 15 | |
| +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ | |
| | count register value | | |
| +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ | |
| Implementation notes: | |
| 1. MPE sets the system clock to a 1 millisecond period and a 100 millisecond | |
| limit to achieve the 10 interrupts per second rate required by the | |
| time-of-day clock maintained by the OS. The short period precludes | |
| idling. Therefore, this configuration is detected and implemented | |
| internally as a 10 millisecond service time with the counter incremented | |
| by 10 for each event service. In addition, the clock service is | |
| synchronized with the CPU process clock service and the ATC poll service | |
| to improve idling. | |
| 2. If the clock is calibrated, a prescaler is used to achieve the 1 second | |
| and 10 second periods while the event service time remains at 100 | |
| milliseconds. For periods shorter than 1 second, and for all realtime | |
| periods, the prescaler is not used. The prescaler is necessary because | |
| the "sim_rtcn_calb" routine in the sim_timer library requires an integer | |
| ticks-per-second parameter. | |
| */ | |
| #include "hp3000_defs.h" | |
| #include "hp3000_io.h" | |
| /* Program constants */ | |
| #define CLK_MULTIPLIER 10 /* number of MPE clock ticks per service */ | |
| #define CLK_RATE (1000 / CLK_MULTIPLIER) /* MPE clock rate in ticks per second */ | |
| static const int32 delay [8] = { /* clock delays, in event ticks per interval */ | |
| 0, /* 000 = unused */ | |
| uS (10), /* 001 = 10 microseconds */ | |
| uS (100), /* 010 = 100 microseconds */ | |
| mS (1), /* 011 = 1 millisecond */ | |
| mS (10), /* 100 = 10 milliseconds */ | |
| mS (100), /* 101 = 100 milliseconds */ | |
| S (1), /* 110 = 1 second */ | |
| S (10) /* 111 = 10 seconds */ | |
| }; | |
| static const int32 ticks [8] = { /* clock ticks per second */ | |
| 0, /* 000 = unused */ | |
| 100000, /* 001 = 10 microseconds */ | |
| 10000, /* 010 = 100 microseconds */ | |
| 1000, /* 011 = 1 millisecond */ | |
| 100, /* 100 = 10 milliseconds */ | |
| 10, /* 101 = 100 milliseconds */ | |
| 10, /* 110 = 1 second */ | |
| 10 /* 111 = 10 seconds */ | |
| }; | |
| static const int32 scale [8] = { /* prescaler counts per clock tick */ | |
| 1, /* 000 = unused */ | |
| 1, /* 001 = 10 microseconds */ | |
| 1, /* 010 = 100 microseconds */ | |
| 1, /* 011 = 1 millisecond */ | |
| 1, /* 100 = 10 milliseconds */ | |
| 1, /* 101 = 100 milliseconds */ | |
| 10, /* 110 = 1 second */ | |
| 100 /* 111 = 10 seconds */ | |
| }; | |
| /* Unit flags */ | |
| #define UNIT_CALTIME_SHIFT (UNIT_V_UF + 0) /* calibrated timing mode */ | |
| #define UNIT_CALTIME (1u << UNIT_CALTIME_SHIFT) | |
| /* Debug flags */ | |
| #define DEB_CSRW (1u << 0) /* trace commands received and status returned */ | |
| #define DEB_PSERV (1u << 1) /* trace unit service scheduling calls */ | |
| #define DEB_IOB (1u << 2) /* trace I/O bus signals and data words exchanged */ | |
| /* Control word. | |
| 0 | 1 2 3 | 4 5 6 | 7 8 9 |10 11 12 |13 14 15 | |
| +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ | |
| | M / rate | E | - | irq reset | C | L | A | - - - - | I | | |
| +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ | |
| */ | |
| #define CN_MR 0100000u /* (M) master reset (if bit 3 = 0) */ | |
| #define CN_RATE_MASK 0160000u /* clock rate selector mask (if bit 3 = 1) */ | |
| #define CN_RESET_LOAD_SEL 0010000u /* (E) select reset/load rate (0/1) */ | |
| #define CN_IRQ_RESET_MASK 0003400u /* interrupt request reset selector mask */ | |
| #define CN_COUNT_RESET 0000200u /* (C) reset count register after LR=CR interrupt */ | |
| #define CN_LIMIT_COUNT_SEL 0000100u /* (L) select limit/count (0/1) register */ | |
| #define CN_IRQ_RESET_ALL 0000040u /* (A) reset all interrupt requests */ | |
| #define CN_IRQ_ENABLE 0000001u /* (I) enable clock interrupts */ | |
| #define CN_RATE_SHIFT 13 /* clock rate alignment shift */ | |
| #define CN_IRQ_RESET_SHIFT 8 /* interrupt request reset alignment shift */ | |
| #define CN_RATE(c) (((c) & CN_RATE_MASK) >> CN_RATE_SHIFT) | |
| #define CN_RESET(c) (((c) & CN_IRQ_RESET_MASK) >> CN_IRQ_RESET_SHIFT) | |
| static const char *const rate_name [8] = { /* clock rate selector names */ | |
| "unused", /* 000 = unused */ | |
| "10 microsecond", /* 001 = 10 microseconds */ | |
| "100 microsecond", /* 010 = 100 microseconds */ | |
| "1 millisecond", /* 011 = 1 millisecond */ | |
| "10 millisecond", /* 100 = 10 milliseconds */ | |
| "100 millisecond", /* 101 = 100 milliseconds */ | |
| "1 second", /* 110 = 1 second */ | |
| "10 second" /* 111 = 10 seconds */ | |
| }; | |
| static const char *const irq_reset_name [8] = { /* IRQ reset selector names */ | |
| "", /* 000 = none */ | |
| " | reset LR = CR irq", /* 001 = LR equal CR */ | |
| " | reset LR = CR overflow irq", /* 010 = LR equal CR overflow */ | |
| " | reset SIN irq", /* 011 = I/O system */ | |
| "", /* 100 = unused */ | |
| "", /* 101 = unused */ | |
| "", /* 110 = unused */ | |
| "" /* 111 = unused */ | |
| }; | |
| static const BITSET_NAME control_names [] = { /* Control word names */ | |
| "master reset", /* bit 0 */ | |
| NULL, /* bit 1 */ | |
| NULL, /* bit 2 */ | |
| "load rate", /* bit 3 */ | |
| NULL, /* bit 4 */ | |
| NULL, /* bit 5 */ | |
| NULL, /* bit 6 */ | |
| NULL, /* bit 7 */ | |
| "reset count", /* bit 8 */ | |
| "\1select count\0select limit", /* bit 9 */ | |
| "reset interrupts", /* bit 10 */ | |
| NULL, /* bit 11 */ | |
| NULL, /* bit 12 */ | |
| NULL, /* bit 13 */ | |
| NULL, /* bit 14 */ | |
| "enable interrupts" /* bit 15 */ | |
| }; | |
| static const BITSET_FORMAT control_format = /* names, offset, direction, alternates, bar */ | |
| { FMT_INIT (control_names, 0, msb_first, has_alt, no_bar) }; | |
| /* Status word. | |
| 0 | 1 2 3 | 4 5 6 | 7 8 9 |10 11 12 |13 14 15 | |
| +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ | |
| | - | D | rate | - - - - - | C | F | - | I | L | R | | |
| +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ | |
| */ | |
| #define ST_DIO_OK 0040000u /* (D) direct I/O OK to use */ | |
| #define ST_RATE_MASK 0034000u /* clock rate mask */ | |
| #define ST_LR_EQ_CR 0000040u /* (C) limit register = count register */ | |
| #define ST_LR_EQ_CR_OVFL 0000020u /* (F) limit register = count register overflow */ | |
| #define ST_SYSTEM_IRQ 0000004u /* (I) I/O system interrupt request */ | |
| #define ST_LIMIT_COUNT_SEL 0000002u /* (L) limit/count (0/1) register selected */ | |
| #define ST_COUNT_RESET 0000001u /* (R) count register is reset after LR=CR interrupt */ | |
| #define ST_RATE_SHIFT 11 /* clock rate alignment shift */ | |
| #define ST_RATE(r) ((r) << ST_RATE_SHIFT & ST_RATE_MASK) | |
| #define ST_TO_RATE(s) (((s) & ST_RATE_MASK) >> ST_RATE_SHIFT) | |
| static const BITSET_NAME status_names [] = { /* Status word names */ | |
| "DIO OK", /* bit 1 */ | |
| NULL, /* bit 2 */ | |
| NULL, /* bit 3 */ | |
| NULL, /* bit 4 */ | |
| NULL, /* bit 5 */ | |
| NULL, /* bit 6 */ | |
| NULL, /* bit 7 */ | |
| NULL, /* bit 8 */ | |
| NULL, /* bit 9 */ | |
| "LR = CR", /* bit 10 */ | |
| "LR = CR overflow", /* bit 11 */ | |
| NULL, /* bit 12 */ | |
| "system interrupt", /* bit 13 */ | |
| "\1count selected\0limit selected", /* bit 14 */ | |
| "reset after interrupt" /* bit 15 */ | |
| }; | |
| static const BITSET_FORMAT status_format = /* names, offset, direction, alternates, bar */ | |
| { FMT_INIT (status_names, 0, msb_first, has_alt, append_bar) }; | |
| /* System clock state */ | |
| static FLIP_FLOP system_irq = CLEAR; /* SIN interrupt request flip-flop */ | |
| static FLIP_FLOP limit_irq = CLEAR; /* limit = count interrupt request flip-flop */ | |
| static FLIP_FLOP lost_tick_irq = CLEAR; /* limit = count overflow interrupt request flip-flop */ | |
| static HP_WORD control_word; /* control word */ | |
| static HP_WORD status_word; /* status word */ | |
| static HP_WORD count_register; /* counter register */ | |
| static HP_WORD limit_register; /* limit register */ | |
| static uint32 rate; /* clock rate */ | |
| static uint32 prescaler; /* clock rate prescaler */ | |
| static uint32 increment = 1; /* count register increment */ | |
| static t_bool coschedulable = FALSE; /* TRUE if the clock can be coscheduled with PCLK */ | |
| static t_bool coscheduled = FALSE; /* TRUE if the clock is coscheduled with PCLK */ | |
| /* System clock local SCP support routines */ | |
| static CNTLR_INTRF clk_interface; | |
| static t_stat clk_service (UNIT *uptr); | |
| static t_stat clk_reset (DEVICE *dptr); | |
| /* System clock local utility routines */ | |
| static void resync_clock (void); | |
| /* System clock SCP interface data structures */ | |
| /* Device information block */ | |
| static DIB clk_dib = { | |
| &clk_interface, /* device interface */ | |
| 3, /* device number */ | |
| SRNO_UNUSED, /* service request number */ | |
| 1, /* interrupt priority */ | |
| INTMASK_UNUSED /* interrupt mask */ | |
| }; | |
| /* Unit list */ | |
| static UNIT clk_unit [] = { | |
| { UDATA (&clk_service, UNIT_IDLE | UNIT_CALTIME, 0) } | |
| }; | |
| /* Register list */ | |
| static REG clk_reg [] = { | |
| /* Macro Name Location Width Offset Flags */ | |
| /* ------ ------ ----------------- ----- ------ ------------------ */ | |
| { ORDATA (CNTL, control_word, 16) }, | |
| { ORDATA (STAT, status_word, 16) }, | |
| { ORDATA (COUNT, count_register, 16) }, | |
| { ORDATA (LIMIT, limit_register, 16) }, | |
| { ORDATA (RATE, rate, 3) }, | |
| { FLDATA (SYSIRQ, system_irq, 0) }, | |
| { FLDATA (LIMIRQ, limit_irq, 0) }, | |
| { FLDATA (OVFIRQ, lost_tick_irq, 0) }, | |
| { DRDATA (SCALE, prescaler, 16), REG_HRO }, | |
| { DRDATA (INCR, increment, 16), REG_HRO }, | |
| { FLDATA (COSOK, coschedulable, 0), REG_HRO }, | |
| { FLDATA (COSCH, coscheduled, 0), REG_HRO }, | |
| { DRDATA (UWAIT, clk_unit [0].wait, 32), PV_LEFT | REG_HRO }, | |
| DIB_REGS (clk_dib), | |
| { NULL } | |
| }; | |
| /* Modifier list */ | |
| static MTAB clk_mod [] = { | |
| /* Mask Value Match Value Print String Match String Validation Display Descriptor */ | |
| /* ------------ ------------ ------------------- ------------ ---------- ------- ---------- */ | |
| { UNIT_CALTIME, UNIT_CALTIME, "calibrated timing", "CALTIME", NULL, NULL, NULL }, | |
| { UNIT_CALTIME, 0, "realistic timing", "REALTIME", NULL, NULL, NULL }, | |
| /* Entry Flags Value Print String Match String Validation Display Descriptor */ | |
| /* ----------- ----------- ------------ ------------ ------------ ------------- ----------------- */ | |
| { MTAB_XDV, VAL_DEVNO, "DEVNO", "DEVNO", &hp_set_dib, &hp_show_dib, (void *) &clk_dib }, | |
| { MTAB_XDV, VAL_INTPRI, "INTPRI", "INTPRI", &hp_set_dib, &hp_show_dib, (void *) &clk_dib }, | |
| { 0 } | |
| }; | |
| /* Debugging trace list */ | |
| static DEBTAB clk_deb [] = { | |
| { "CSRW", DEB_CSRW }, /* interface control, status, read, and write actions */ | |
| { "PSERV", DEB_PSERV }, /* clock unit service scheduling calls */ | |
| { "IOBUS", DEB_IOB }, /* interface I/O bus signals and data words */ | |
| { NULL, 0 } | |
| }; | |
| /* Device descriptor */ | |
| DEVICE clk_dev = { | |
| "CLK", /* device name */ | |
| clk_unit, /* unit array */ | |
| clk_reg, /* register array */ | |
| clk_mod, /* modifier array */ | |
| 1, /* number of units */ | |
| 8, /* address radix */ | |
| PA_WIDTH, /* address width */ | |
| 1, /* address increment */ | |
| 8, /* data radix */ | |
| DV_WIDTH, /* data width */ | |
| NULL, /* examine routine */ | |
| NULL, /* deposit routine */ | |
| &clk_reset, /* reset routine */ | |
| NULL, /* boot routine */ | |
| NULL, /* attach routine */ | |
| NULL, /* detach routine */ | |
| &clk_dib, /* device information block pointer */ | |
| DEV_DISABLE | DEV_DEBUG, /* device flags */ | |
| 0, /* debug control flags */ | |
| clk_deb, /* debug flag name array */ | |
| NULL, /* memory size change routine */ | |
| NULL /* logical device name */ | |
| }; | |
| /* System clock global routines */ | |
| /* Update the counter register. | |
| If the clock is currently coscheduled with the CPU process clock, then the | |
| service interval is actually ten times the programmed rate. To present the | |
| correct value when the counter register is read, this routine is called to | |
| increment the count by an amount proportional to the fraction of the service | |
| interval that has elapsed. In addition, it's called by the CPU instruction | |
| postlude, so that the counter will have the correct value if it's examined | |
| from the SCP command prompt. | |
| This routine is also called when the counter is to be reset. This ensures | |
| that the increment is reduced by the time elapsed before the counter is | |
| zeroed. | |
| */ | |
| void clk_update_counter (void) | |
| { | |
| int32 elapsed, ticks; | |
| if (coscheduled) { /* if the clock is coscheduled, then adjust the count */ | |
| elapsed = clk_unit [0].wait /* the elapsed time is the original wait time */ | |
| - sim_activate_time (&clk_unit [0]); /* less the time remaining before the next service */ | |
| ticks = (elapsed * CLK_MULTIPLIER) / clk_unit [0].wait /* the adjustment is the elapsed fraction of the multiplier */ | |
| - (CLK_MULTIPLIER - increment); /* less the amount of any adjustment already made */ | |
| count_register = count_register + ticks & R_MASK; /* update the clock counter with rollover */ | |
| increment = increment - ticks; /* and reduce the amount remaining to add at service */ | |
| } | |
| return; | |
| } | |
| /* System clock local SCP support routines */ | |
| /* System clock interface. | |
| The system clock is installed on the IOP bus and receives direct I/O commands | |
| from the IOP. It does not respond to Programmed I/O (SIO) commands. | |
| In simulation, the asserted signals on the bus are represented as bits in the | |
| inbound_signals set. Each signal is processed sequentially in numerical | |
| order, and a set of similar outbound_signals is assembled and returned to the | |
| caller, simulating assertion of the corresponding bus signals. | |
| There is no interrupt mask; interrupts are always unmasked, and the interface | |
| does not respond to the SMSK I/O order. | |
| Implementation notes: | |
| 1. In hardware, setting the tick rate in the control word addresses a | |
| multiplexer that selects one of the 10 MHz clock division counter outputs | |
| as the clock source for the count register. Setting the rate bits to 0 | |
| inhibits the count register, although the division counter continues to | |
| run. In simulation, setting a new rate stops and then restarts the event | |
| service with the new delay time, equivalent in hardware to clearing the | |
| clock division counter. | |
| 2. Receipt of a DRESETINT signal clears the interrupt request and active | |
| flip-flops but does not cancel a request that is pending but not yet | |
| serviced by the IOP. However, when the IOP does service the request by | |
| asserting INTPOLLIN, the interface routine returns INTPOLLOUT, which will | |
| cancel the request. | |
| 3. The "%.0s" print specification in the DCONTSTB trace call absorbs the | |
| rate name parameter without printing when the rate is not specified. | |
| */ | |
| static SIGNALS_DATA clk_interface (DIB *dibptr, INBOUND_SET inbound_signals, HP_WORD inbound_value) | |
| { | |
| INBOUND_SIGNAL signal; | |
| INBOUND_SET working_set = inbound_signals; | |
| HP_WORD outbound_value = 0; | |
| OUTBOUND_SET outbound_signals = NO_SIGNALS; | |
| dprintf (clk_dev, DEB_IOB, "Received data %06o with signals %s\n", | |
| inbound_value, fmt_bitset (inbound_signals, inbound_format)); | |
| while (working_set) { | |
| signal = IONEXTSIG (working_set); /* isolate the next signal */ | |
| switch (signal) { /* dispatch an I/O signal */ | |
| case DCONTSTB: | |
| control_word = inbound_value; /* save the control word */ | |
| if (control_word & CN_RESET_LOAD_SEL) { /* if the reset/load selector is set */ | |
| rate = CN_RATE (control_word); /* then load the clock rate */ | |
| if (clk_unit [0].flags & UNIT_CALTIME) /* if in calibrated timing mode */ | |
| prescaler = scale [rate]; /* then set the prescaler */ | |
| else /* otherwise */ | |
| prescaler = 1; /* the prescaler isn't used */ | |
| sim_cancel (&clk_unit [0]); /* changing the rate restarts the timing divider */ | |
| if (rate > 0) { /* if the rate is valid */ | |
| clk_unit [0].wait = delay [rate]; /* then set the initial service delay */ | |
| sim_rtcn_init (clk_unit [0].wait, TMR_CLK); /* initialize the clock */ | |
| resync_clock (); /* and reschedule the service */ | |
| } | |
| } | |
| else if (control_word & CN_MR) { /* otherwise, if the master reset bit is set */ | |
| clk_reset (&clk_dev); /* then reset the interface */ | |
| control_word = 0; /* (which clears the other settings) */ | |
| } | |
| if (control_word & CN_IRQ_RESET_ALL) { /* if a reset of all interrupts is requested */ | |
| limit_irq = CLEAR; /* then clear the limit = count, */ | |
| lost_tick_irq = CLEAR; /* limit = count overflow, */ | |
| system_irq = CLEAR; /* and system flip-flops */ | |
| } | |
| else if (control_word & CN_IRQ_RESET_MASK) /* otherwise if any single resets are requested */ | |
| switch (CN_RESET (control_word)) { /* then reset the specified flip-flop */ | |
| case 1: | |
| limit_irq = CLEAR; /* clear the limit = count interrupt request */ | |
| break; | |
| case 2: | |
| lost_tick_irq = CLEAR; /* clear the limit = count overflow interrupt request */ | |
| break; | |
| case 3: | |
| system_irq = CLEAR; /* clear the system interrupt request */ | |
| break; | |
| default: /* the rest of the values do nothing */ | |
| break; | |
| } | |
| if (dibptr->interrupt_active == CLEAR) /* if no interrupt is active */ | |
| working_set |= DRESETINT; /* then recalculate interrupt requests */ | |
| dprintf (clk_dev, DEB_CSRW, (inbound_value & CN_RESET_LOAD_SEL | |
| ? "Control is %s | %s rate%s\n" | |
| : "Control is %s%.0s%s\n"), | |
| fmt_bitset (inbound_value, control_format), | |
| rate_name [CN_RATE (inbound_value)], | |
| irq_reset_name [CN_RESET (inbound_value)]); | |
| break; | |
| case DSTATSTB: | |
| status_word = ST_DIO_OK | ST_RATE (rate); /* set the clock rate */ | |
| if (limit_irq) /* if the limit = count flip-flop is set */ | |
| status_word |= ST_LR_EQ_CR; /* set the corresponding status bit */ | |
| if (lost_tick_irq) /* if the limit = count overflow flip-flop is set */ | |
| status_word |= ST_LR_EQ_CR_OVFL; /* set the corresponding status bit */ | |
| if (system_irq) /* if the system interrupt request flip-flop is set */ | |
| status_word |= ST_SYSTEM_IRQ; /* set the corresponding status bit */ | |
| if (control_word & CN_LIMIT_COUNT_SEL) /* if the limit/count selector is set */ | |
| status_word |= ST_LIMIT_COUNT_SEL; /* set the corresponding status bit */ | |
| if (control_word & CN_COUNT_RESET) /* if the reset-after-interrupt selector is set */ | |
| status_word |= ST_COUNT_RESET; /* set the corresponding status bit */ | |
| outbound_value = status_word; /* return the status word */ | |
| dprintf (clk_dev, DEB_CSRW, "Status is %s%s rate\n", | |
| fmt_bitset (outbound_value, status_format), | |
| rate_name [ST_TO_RATE (outbound_value)]); | |
| break; | |
| case DREADSTB: | |
| clk_update_counter (); /* update the clock counter register */ | |
| outbound_value = LOWER_WORD (count_register); /* and then read it */ | |
| dprintf (clk_dev, DEB_CSRW, "Count register value %u returned\n", | |
| count_register); | |
| break; | |
| case DWRITESTB: | |
| if (control_word & CN_LIMIT_COUNT_SEL) { /* if the limit/count selector is set */ | |
| clk_update_counter (); /* then update the clock counter register */ | |
| count_register = 0; /* and then clear it */ | |
| dprintf (clk_dev, DEB_CSRW, "Count register cleared\n"); | |
| } | |
| else { /* otherwise */ | |
| limit_register = inbound_value; /* set the limit register to the supplied value */ | |
| dprintf (clk_dev, DEB_CSRW, "Limit register value %u set\n", | |
| limit_register); | |
| coschedulable = (ticks [rate] == 1000 /* the clock can be coscheduled if the rate */ | |
| && limit_register == 100); /* is 1 msec and the limit is 100 ticks */ | |
| } | |
| break; | |
| case DSETINT: | |
| system_irq = SET; /* set the system interrupt request flip-flop */ | |
| dibptr->interrupt_request = SET; /* request an interrupt */ | |
| outbound_signals |= INTREQ; /* and notify the IOP */ | |
| break; | |
| case DRESETINT: | |
| dibptr->interrupt_active = CLEAR; /* clear the Interrupt Active flip-flop */ | |
| if ((limit_irq == SET || lost_tick_irq == SET) /* if the limit or lost tick flip-flops are set */ | |
| && control_word & CN_IRQ_ENABLE) /* and interrupts are enabled */ | |
| dibptr->interrupt_request = SET; /* then set the interrupt request flip-flop */ | |
| else /* otherwise */ | |
| dibptr->interrupt_request = system_irq; /* request an interrupt if the system flip-flop is set */ | |
| if (dibptr->interrupt_request) /* if a request is pending */ | |
| outbound_signals |= INTREQ; /* then notify the IOP */ | |
| break; | |
| case INTPOLLIN: | |
| if (dibptr->interrupt_request) { /* if a request is pending */ | |
| dibptr->interrupt_request = CLEAR; /* then clear it */ | |
| dibptr->interrupt_active = SET; /* and mark it as now active */ | |
| outbound_signals |= INTACK; /* acknowledge the interrupt */ | |
| outbound_value = dibptr->device_number; /* and return our device number */ | |
| } | |
| else /* otherwise the request has been reset */ | |
| outbound_signals |= INTPOLLOUT; /* so let the IOP know to cancel it */ | |
| break; | |
| case DSTARTIO: /* not used by this interface */ | |
| case DSETMASK: /* not used by this interface */ | |
| case ACKSR: /* not used by this interface */ | |
| case TOGGLESR: /* not used by this interface */ | |
| case SETINT: /* not used by this interface */ | |
| case PCMD1: /* not used by this interface */ | |
| case PCONTSTB: /* not used by this interface */ | |
| case SETJMP: /* not used by this interface */ | |
| case PSTATSTB: /* not used by this interface */ | |
| case PWRITESTB: /* not used by this interface */ | |
| case PREADSTB: /* not used by this interface */ | |
| case EOT: /* not used by this interface */ | |
| case TOGGLEINXFER: /* not used by this interface */ | |
| case TOGGLEOUTXFER: /* not used by this interface */ | |
| case READNEXTWD: /* not used by this interface */ | |
| case TOGGLESIOOK: /* not used by this interface */ | |
| case DEVNODB: /* not used by this interface */ | |
| case XFERERROR: /* not used by this interface */ | |
| case CHANSO: /* not used by this interface */ | |
| case PFWARN: /* not used by this interface */ | |
| break; | |
| } | |
| IOCLEARSIG (working_set, signal); /* remove the current signal from the set */ | |
| } | |
| dprintf (clk_dev, DEB_IOB, "Returned data %06o with signals %s\n", | |
| outbound_value, fmt_bitset (outbound_signals, outbound_format)); | |
| return IORETURN (outbound_signals, outbound_value); /* return the outbound signals and value */ | |
| } | |
| /* Service the system clock unit. | |
| At each "tick" of the clock, the count register is incremented and compared | |
| to the limit register. If they are equal, then the counter is cleared (if | |
| enabled) and an interrupt is generated (if enabled). | |
| If the clock is calibrated, a prescaler is used to achieve the 1 second and | |
| 10 second periods while the event time remains at 100 milliseconds. For | |
| periods shorter than 1 second, and for all realtime periods, the prescaler is | |
| not used (by setting the value to 1). | |
| If the clock is currently coscheduled with the CPU process clock, then the | |
| service interval is actually ten times the programmed rate, so the count | |
| register increment per service entry is 10 instead of 1. | |
| Implementation notes: | |
| 1. The count/limit comparison hardware provides only an equal condition. If | |
| the limit register is set to a value below the current count, or the | |
| LR=CR interrupt is not enabled until after the count register value has | |
| exceeded the limit, comparison will not occur until the count register | |
| overflows and again reaches the limit. | |
| */ | |
| static t_stat clk_service (UNIT *uptr) | |
| { | |
| dprintf (clk_dev, DEB_PSERV, "Service entered with counter %u increment %u limit %u\n", | |
| count_register, increment, limit_register); | |
| prescaler = prescaler - 1; /* decrement the prescaler count */ | |
| if (prescaler == 0) { /* if the prescaler count has expired */ | |
| count_register = count_register + increment & R_MASK; /* then the count register counts up */ | |
| if (count_register == limit_register) { /* if the limit has been reached */ | |
| if (limit_irq == SET) /* then if the last limit interrupt wasn't serviced */ | |
| lost_tick_irq = SET; /* then set the overflow interrupt */ | |
| else /* otherwise */ | |
| limit_irq = SET; /* set the limit interrupt */ | |
| if (control_word & CN_COUNT_RESET) /* if the counter reset option is selected */ | |
| count_register = 0; /* then clear the count register */ | |
| if (control_word & CN_IRQ_ENABLE /* if clock interrupts are enabled */ | |
| && clk_dib.interrupt_active == CLEAR) { /* and the interrupt active flip-flop is clear */ | |
| clk_dib.interrupt_request = SET; /* then request an interrupt */ | |
| iop_assert_INTREQ (&clk_dib); /* and notify the IOP of the INTREQ signal */ | |
| } | |
| } | |
| if (uptr->flags & UNIT_CALTIME) /* if in calibrated timing mode */ | |
| prescaler = scale [rate]; /* then reset the prescaler */ | |
| else /* otherwise */ | |
| prescaler = 1; /* the prescaler isn't used */ | |
| } | |
| if (!(uptr->flags & UNIT_CALTIME)) { /* if the clock is in real timing mode */ | |
| uptr->wait = delay [rate]; /* then set an event-based delay */ | |
| increment = 1; /* equal to the selected period */ | |
| coscheduled = FALSE; /* the clock is not coscheduled with the process clock */ | |
| } | |
| else if (coschedulable && cpu_is_calibrated) { /* otherwise if the process clock is calibrated */ | |
| uptr->wait = sim_activate_time (cpu_pclk_uptr); /* then synchronize with it */ | |
| increment = CLK_MULTIPLIER; /* at one-tenth of the selected period */ | |
| coscheduled = TRUE; /* the clock is coscheduled with the process clock */ | |
| } | |
| else { /* otherwise */ | |
| uptr->wait = sim_rtcn_calb (ticks [rate], TMR_CLK); /* calibrate the clock to a delay */ | |
| increment = 1; /* equal to the selected period */ | |
| coscheduled = FALSE; /* the clock is not coscheduled with the process clock */ | |
| } | |
| dprintf (clk_dev, DEB_PSERV, "Rate %s delay %d service %s\n", | |
| rate_name [rate], uptr->wait, | |
| (coscheduled ? "coscheduled" : "scheduled")); | |
| return sim_activate (uptr, uptr->wait); /* activate the unit and return the status */ | |
| } | |
| /* Device reset. | |
| This routine is called for a RESET or RESET CLK command. It is the | |
| simulation equivalent of the IORESET signal, which is asserted by the front | |
| panel LOAD and DUMP switches. | |
| For this interface, IORESET is identical to a Programmed Master Reset | |
| (control word bit 0 set with bit 3 clear). | |
| A master reset is generated either by an IORESET signal or a Direct I/O | |
| Master Reset (control word bit 0 set with bit 3 clear). | |
| Implementation notes: | |
| 1. In simulation, the Enable Clock Interrupts flip-flop, the Reset Count | |
| Register after LR=CR Interrupt flip-flop, and the Address Limit/Count | |
| Register flip-flop are maintained in the control word rather than as | |
| separate values. | |
| 2. The hardware interrupt circuitry contains an Interrupt Active flip-flop | |
| and an Interrupt Priority latch but no Interrupt Request flip-flop. | |
| Instead, the INTREQ signal is the logical OR of the LR=CR Interrupt and | |
| LR=CR Overflow Interrupt flip-flops (if enabled by the Enable Clock | |
| Interrupts flip-flop) with the the System Interrupt flip-flop. In | |
| simulation, the interrupt_request flip-flop in the Device Information | |
| Block is set explicitly to reflect this logic. Clearing the three | |
| interrupt source flip-flops therefore clears the interrupt_request | |
| flip-flop as well. | |
| 3. In simulation, the clock division counters are represented by the event | |
| service delay. Stopping and restarting the delay is equivalent to | |
| clearing the division counters. | |
| */ | |
| static t_stat clk_reset (DEVICE *dptr) | |
| { | |
| count_register = 0; /* clear the count */ | |
| limit_register = 0; /* and limit registers */ | |
| rate = 0; /* clear the clock rate */ | |
| prescaler = 1; /* and set the clock prescaler */ | |
| sim_cancel (dptr->units); /* clearing the rate stops the clock */ | |
| clk_dib.interrupt_request = CLEAR; /* clear any current */ | |
| clk_dib.interrupt_active = CLEAR; /* interrupt request */ | |
| system_irq = CLEAR; /* clear the system, */ | |
| limit_irq = CLEAR; /* limit = count, */ | |
| lost_tick_irq = CLEAR; /* and limit = count overflow flip-flops */ | |
| control_word = 0; /* clear the enable, write select, and count reset actions */ | |
| return SCPE_OK; | |
| } | |
| /* System clock local utility routines */ | |
| /* Resynchronize the clock. | |
| After changing the rate or the limit, the new values are examined to see if | |
| the clock may be coscheduled with the process clock to permit idling. If | |
| coscheduling is possible and both the system clock and the CPU process clock | |
| are calibrated, then the clock event service is synchronized with the process | |
| clock service. Otherwise, the service time is set up but is otherwise | |
| asynchronous with the process clock. | |
| Implementation notes: | |
| 1. To synchronize events, the clock must be activated absolutely, as a | |
| service event may already be scheduled, and normal activation will not | |
| disturb an existing event. | |
| */ | |
| static void resync_clock (void) | |
| { | |
| coschedulable = (ticks [rate] == 1000 /* the clock can be coscheduled if the rate */ | |
| && limit_register == 100); /* is 1 msec and the limit is 100 ticks */ | |
| if (clk_unit [0].flags & UNIT_CALTIME /* if the clock is in calibrated timing mode */ | |
| && coschedulable /* and may be coscheduled with the process clock */ | |
| && cpu_is_calibrated) { /* and the process clock is calibrated */ | |
| clk_unit [0].wait = sim_activate_time (cpu_pclk_uptr); /* then synchronize with it */ | |
| coscheduled = TRUE; /* the clock is coscheduled with the process clock */ | |
| } | |
| else { /* otherwise */ | |
| clk_unit [0].wait = delay [rate]; /* set up an independent clock */ | |
| coscheduled = FALSE; /* the clock is not coscheduled with the process clock */ | |
| } | |
| dprintf (clk_dev, DEB_PSERV, "Rate %s delay %d service rescheduled\n", | |
| rate_name [rate], clk_unit [0].wait); | |
| sim_activate_abs (&clk_unit [0], clk_unit [0].wait); /* restart the clock */ | |
| return; | |
| } |