


	makeqcounters: if QCounters >0 generate
	signal LoadQCounter: std_logic_vector(QCounters-1 downto 0);
	signal ReadQCounter: std_logic_vector(QCounters-1 downto 0);
	signal LoadQCounterCCR: std_logic_vector(QCounters-1 downto 0);
	signal ReadQCounterCCR: std_logic_vector(QCounters-1 downto 0);
	signal QuadA: std_logic_vector(QCounters-1 downto 0);
	signal QuadB: std_logic_vector(QCounters-1 downto 0);
	signal Index: std_logic_vector(QCounters -1 downto 0);
	signal IndexMask: std_logic_vector(QCounters -1 downto 0);
	signal QCounterSel : std_logic;
	signal QCounterCCRSel : std_logic;
	signal LoadTSDiv : std_logic;
	signal ReadTSDiv : std_logic;
	signal ReadTS : std_logic;
	signal TimeStampBus: std_logic_vector(15 downto 0);
	signal LoadQCountRate : std_logic;
	signal QCountFilterRate : std_logic;	

-- dpll only signals	
	signal QCounterDPLLSampleTime: std_logic;
	signal QcounterTimerEnable: std_logic;
	signal LoadQCounterTimerSelect: std_logic;
	signal ReadQCounterTimerSelect: std_logic;
	
-- index offset only signals
	signal LoadQCounterOffset: std_logic_vector(QCounters-1 downto 0);	--
	signal ReadQCounterOffset: std_logic_vector(QCounters-1 downto 0);	--
	signal QCounterOffsetSel : std_logic;
	
	begin
				
		nodpllqcrate: if HM2DPLLs = 0 generate
			qcountratex: entity work.qcounterate
				generic map (clock => ClockLow) -- default encoder clock is 16 MHz
				port map( 
					ibus => ibus(11 downto 0),
					loadRate => LoadQCountRate,
					rateout => QcountFilterRate,
					clk => clklow
				);	
				
				timestampx: entity work.timestamp 
				port map( 
					ibus => ibus(15 downto 0),
					obus => obus(15 downto 0),
					loadtsdiv => LoadTSDiv ,
					readts => ReadTS,
					readtsdiv =>ReadTSDiv,
					tscount => TimeStampBus,
					clk => clklow
				);
		
		end generate nodpllqcrate;
		
		dpllqcrate: if HM2DPLLs > 0 generate
			qcountratedx: entity work.qcounterated
				generic map (clock => ClockLow) -- default encoder clock is 16 MHz
				port map( 
					ibus => ibus,
					obus => obus,
					loadRate => LoadQCountRate,
					loadtimerselect => LoadQCounterTimerSelect,
					readtimerselect => ReadQCounterTimerSelect,
					timers => RateSources,
					timer => QCounterDPLLSampleTime,
					timerenable	=> QcounterTimerEnable,
					rateout => QcountFilterRate,
					clk => clklow
				);				
			timestampxd: entity work.timestampd 
				port map( 
					ibus => ibus(15 downto 0),
					obus => obus(15 downto 0),
					loadtsdiv => LoadTSDiv ,
					readts => ReadTS,
					readtsdiv =>ReadTSDiv,
					tscount => TimeStampBus,
					timer => QCounterDPLLSampleTime,
					timerenable	=> QcounterTimerEnable,
					clk => clklow
				);

		end generate dpllqcrate;		
			
		---------------- index offset ----------------

			nuseprobe1io: if not UseProbe generate
				nodpllqcountersio: if HM2DPLLs = 0 generate
					makequadcountersio: for i in 0 to QCounters-1 generate
						qcounterxio: entity work.qcounterio			--
						generic map (
							buswidth => BusWidth
						)
						port map (
							obus => obus,
							ibus => ibus,
							quada => QuadA(i),
							quadb => QuadB(i),
							index => Index(i),
							loadccr => LoadQcounterCCR(i),
							readccr => ReadQcounterCCR(i),
							readcount => ReadQcounter(i),
							countclear => LoadQcounter(i),
							loadoffset => LoadQcounterOffset(i),	--
							readoffset => ReadQcounterOffset(i),	--
							timestamp => TimeStampBus,
							indexmask => IndexMask(i),
							filterrate => QCountFilterRate,
							clk =>	clklow
						);
					end generate makequadcountersio;
				end generate nodpllqcountersio;
			
				dpllqcountersio: if HM2DPLLs > 0 generate
					makequadcountersdio: for i in 0 to QCounters-1 generate
						qcounterxdio: entity work.qcounterdio			--
						generic map (
							buswidth => BusWidth
						)
						port map (
							obus => obus,
							ibus => ibus,
							quada => QuadA(i),
							quadb => QuadB(i),
							index => Index(i),
							loadccr => LoadQcounterCCR(i),
							readccr => ReadQcounterCCR(i),
							readcount => ReadQcounter(i),
							countclear => LoadQcounter(i),
							loadoffset => LoadQcounterOffset(i),	--
							readoffset => ReadQcounterOffset(i),	--
							timestamp => TimeStampBus,
							indexmask => IndexMask(i),
							filterrate => QCountFilterRate,
							timer => QCounterDPLLSampleTime,
							timerenable	=> QcounterTimerEnable,
							clk =>	clklow
						);
					end generate makequadcountersdio;
				end generate dpllqcountersio;
			end generate nuseprobe1io;

			useprobe1io: if UseProbe generate
				nodpllqcounterspio: if HM2DPLLs = 0 generate
					makequadcounterspio: for i in 0 to QCounters-1 generate
						qcounterxpio: entity work.qcounterpio			--
						generic map (
							buswidth => BusWidth
						)
						port map (
							obus => obus,
							ibus => ibus,
							quada => QuadA(i),
							quadb => QuadB(i),
							index => Index(i),
							loadccr => LoadQcounterCCR(i),
							readccr => ReadQcounterCCR(i),
							readcount => ReadQcounter(i),
							countclear => LoadQcounter(i),
							loadoffset => LoadQcounterOffset(i),	--
							readoffset => ReadQcounterOffset(i),	--
							timestamp => TimeStampBus,
							indexmask => IndexMask(i),
							filterrate => QCountFilterRate,
							probe => Probe,
							clk =>	clklow
						);
					end generate makequadcounterspio;
				end generate nodpllqcounterspio;
			
				dpllqcounterspio: if HM2DPLLs > 0 generate
					makequadcounterspdio: for i in 0 to QCounters-1 generate
						qcounterxpdio: entity work.qcounterpdio			--
						generic map (
							buswidth => BusWidth
						)
						port map (
							obus => obus,
							ibus => ibus,
							quada => QuadA(i),
							quadb => QuadB(i),
							index => Index(i),
							loadccr => LoadQcounterCCR(i),
							readccr => ReadQcounterCCR(i),
							readcount => ReadQcounter(i),
							countclear => LoadQcounter(i),
							loadoffset => LoadQcounterOffset(i),	--
							readoffset => ReadQcounterOffset(i),	--
							timestamp => TimeStampBus,
							indexmask => IndexMask(i),
							filterrate => QCountFilterRate,
							probe => Probe,
							timer => QCounterDPLLSampleTime,
							timerenable	=> QcounterTimerEnable,
							clk =>	clklow
						);
					end generate makequadcounterspdio;
				end generate dpllqcounterspio;
			end generate useprobe1io;

			QCounterIODecodeProcess : process (A,Readstb,writestb,QCounterSel, QCounterCCRSel, QCounterOffsetSel)
			begin
				if A(15 downto 8) = QCounterAddr then	 --  QCounter select
					QCounterSel <= '1';
				else
					QCounterSel <= '0';
				end if;
				if ((A(15 downto 8) = QCounterCCRAddr) and (A(7) = '0')) then	 --  QCounter CCR register select
					QCounterCCRSel <= '1';
				else
					QCounterCCRSel <= '0';
				end if;
				if ((A(15 downto 8) = QCounterCCRAddr) and (A(7) = '1')) then	 --  QCounter Index Offset register select
					QCounterOffsetSel <= '1';
				else
					QCounterOffsetSel <= '0';
				end if;
				if A(15 downto 8) = TSDivAddr and writestb = '1' then	 --  
					LoadTSDiv <= '1';
				else
					LoadTSDiv <= '0';
				end if;		
				if A(15 downto 8) = TSDivAddr and readstb = '1' then	 --  
					ReadTSDiv <= '1';
				else
					ReadTSDiv <= '0';
				end if;
				if A(15 downto 8) = TSAddr and readstb = '1' then	 --  
					ReadTS <= '1';
				else
					ReadTS <= '0';
				end if;
				if A(15 downto 8) = QCRateAddr and writestb = '1' then	 --  
					LoadQCountRate <= '1';
				else
					LoadQCountRate <= '0';
				end if;
				if A(15 downto 8) = QCtimerSelectAddr and writestb = '1' then	 --  
					LoadQCounterTimerSelect <= '1';
				else
					LoadQcounterTimerSelect <= '0';
				end if;
				if A(15 downto 8) = QCtimerSelectAddr and readstb = '1' then	 --  
					ReadQCounterTimerSelect <= '1';
				else
					ReadQCounterTimerSelect <= '0';
				end if;		

				LoadQCounter <= OneOfNDecode(QCounters,QCounterSel,writestb,A(6 downto 2));  -- 32 max
				ReadQCounter <= OneOfNDecode(QCounters,QCounterSel,Readstb,A(6 downto 2));
				LoadQCounterCCR <= OneOfNDecode(QCounters,QCounterCCRSel,writestb,A(6 downto 2));
				ReadQCounterCCR <= OneOfNDecode(QCounters,QCounterCCRSel,Readstb,A(6 downto 2));
				LoadQCounterOffset <= OneOfNDecode(QCounters,QCounterOffsetSel,writestb,A(6 downto 2));
				ReadQCounterOffset <= OneOfNDecode(QCounters,QCounterOffsetSel,Readstb,A(6 downto 2));
			end process QCounterIODecodeProcess;

		DoQCounterPins: process(IOBits)
		begin	
			for i in 0 to IOWidth -1 loop				-- loop through all the external I/O pins 
				if ThePinDesc(i)(15 downto 8) = QCountTag then											
					case (ThePinDesc(i)(7 downto 0)) is	--secondary pin function
						when QCountQAPin =>
							QuadA(conv_integer(ThePinDesc(i)(23 downto 16))) <= IOBits(i); 
						when QCountQBPin =>
							QuadB(conv_integer(ThePinDesc(i)(23 downto 16))) <= IOBits(i);
						when QCountIdxPin =>
							Index(conv_integer(ThePinDesc(i)(23 downto 16))) <= IOBits(i);
						when QCountIdxMaskPin =>
							IndexMask(conv_integer(ThePinDesc(i)(23 downto 16))) <= IOBits(i);
						when QCountProbePin =>
							Probe <= IOBits(i);	-- only 1 please!
						when others => null;
					end case;
				end if;
			end loop;
		end process;		

	end generate makeqcounters;
	
	makemuxedqcounters: if MuxedQCounters >0 generate	
	signal LoadMuxedQCounter: std_logic_vector(MuxedQCounters-1 downto 0);
	signal ReadMuxedQCounter: std_logic_vector(MuxedQCounters-1 downto 0);
	signal LoadMuxedQCounterCCR: std_logic_vector(MuxedQCounters-1 downto 0);
	signal ReadMuxedQCounterCCR: std_logic_vector(MuxedQCounters-1 downto 0);
	signal MuxedQuadA: std_logic_vector(MuxedQCounters/2 -1 downto 0); -- 2 should be muxdepth constant?
	signal MuxedQuadB: std_logic_vector(MuxedQCounters/2 -1 downto 0);
	signal MuxedIndex: std_logic_vector(MuxedQCounters/2 -1 downto 0);
	signal MuxedIndexMask: std_logic_vector(MuxedQCounters -1 downto 0);	
	signal MuxedIndexMaskMIM: std_logic_vector(MuxedQCountersMIM/2 -1 downto 0);	
	signal DemuxedIndexMask: std_logic_vector(MuxedQCountersMIM -1 downto 0);	
	signal DeMuxedQuadA: std_logic_vector(MuxedQCounters -1 downto 0);
	signal DeMuxedQuadB: std_logic_vector(MuxedQCounters -1 downto 0);
	signal DeMuxedIndex: std_logic_vector(MuxedQCounters -1 downto 0);	
	signal MuxedQCounterSel : std_logic;
	signal MuxedQCounterCCRSel : std_logic;
	signal MuxedProbe : std_logic; -- only 1!
	signal LoadMuxedTSDiv : std_logic;
	signal ReadMuxedTSDiv : std_logic;
	signal ReadMuxedTS : std_logic;
	signal MuxedTimeStampBus: std_logic_vector(15 downto 0);
	signal LoadMuxedQCountRate : std_logic;
	signal TwoxMuxedQCountFilterRate : std_logic;	
	signal MuxedQCountFilterRate : std_logic;	
	signal PrePreMuxedQctrSel : std_logic_vector(1 downto 0);
	signal PreMuxedQctrSel : std_logic_vector(1 downto 0);
	signal MuxedQCtrSel : std_logic_vector(1 downto 0);
	signal PreMuxedQCtrSampleTime : std_logic_vector(1 downto 0);
	signal MuxedQCtrSampleTime : std_logic_vector(1 downto 0);
	signal MuxedQCountDeskew : std_logic_vector(3 downto 0);	

-- dpll only signals	
	signal MuxedQCtrDPLLSampleTime: std_logic;
	signal MuxedQCtrTimerEnable: std_logic;
	signal LoadMuxedQCtrTimerSelect: std_logic;
	signal ReadMuxedQCtrTimerSelect: std_logic;

-- index offset only signals
	signal LoadMuxedQCounterOffset: std_logic_vector(MuxedQCounters-1 downto 0);
	signal ReadMuxedQCounterOffset: std_logic_vector(MuxedQCounters-1 downto 0);
	signal MuxedQCounterOffsetSel : std_logic;


	begin

		nodpllqcratem: if HM2DPLLs = 0 generate
			qcountratemx: entity work.qcounteratesk
				generic map (clock => ClockLow) -- default encoder clock is 16 MHz
				port map( 
					ibus => ibus,
					loadRate => LoadMuxedQCountRate,
					rateout => TwoxMuxedQcountFilterRate,
					clk => clklow
				);	
			timestampx: entity work.timestamp 
				port map( 
					ibus => ibus(15 downto 0),
					obus => obus(15 downto 0),
					loadtsdiv => LoadMuxedTSDiv,
					readts => ReadMuxedTS,
					readtsdiv => ReadMuxedTSDiv,
					tscount => MuxedTimeStampBus,
					clk => clklow
				);				
		end generate nodpllqcratem;
		
		dpllqcratem: if HM2DPLLs > 0 generate
			qcountratemdx: entity work.qcounterateskd
				generic map (clock => ClockLow) -- default encoder clock is 16 MHz
				port map( 
					ibus => ibus,
					obus => obus,
					loadRate => LoadMuxedQCountRate,
					loadtimerselect => LoadMuxedQCtrTimerSelect,
					readtimerselect => ReadMuxedQCtrTimerSelect,
					timers => RateSources,
					timer => MuxedQCtrDPLLSampleTime,
					timerenable	=> MuxedQCtrTimerEnable,
					rateout => TwoxMuxedQcountFilterRate,
					deskewout => MuxedQCountDeskew,
					clk => clklow
				);				
			timestampxd: entity work.timestampd 
				port map( 
					ibus => ibus(15 downto 0),
					obus => obus(15 downto 0),
					loadtsdiv => LoadMuxedTSDiv,
					readts => ReadMuxedTS,
					readtsdiv => ReadMuxedTSDiv,
					tscount => MuxedTimeStampBus,
					timer => MuxedQCtrDPLLSampleTime,
					timerenable	=> MuxedQCtrTimerEnable,
					clk => clklow
				);
		end generate dpllqcratem;
		
		qcountermuxdeskew: entity work.srl16delay
			generic map ( width => 2)
			port map (
			   clk => clklow,
				dlyin => PrePreMuxedQCtrSel,
				dlyout => PreMuxedQCtrSampleTime,
				delay => MuxedQCountDeskew
			);

		---------------- muxed index offset ----------------

			nuseprobe2io: if not UseMuxedProbe generate
				nodpllmuxedqcountersio: if HM2DPLLs = 0 generate
					makemuxedquadcountersio: for i in 0 to MuxedQCounters-1 generate
						qcounterxio: entity work.qcounterio	--
						generic map (
							buswidth => BusWidth
						)
						port map (
							obus => obus,
							ibus => ibus,
							quada => DemuxedQuadA(i),
							quadb => DemuxedQuadB(i),
							index => DemuxedIndex(i),
							loadccr => LoadMuxedQcounterCCR(i),
							readccr => ReadMuxedQcounterCCR(i),
							readcount => ReadMuxedQcounter(i),
							countclear => LoadMuxedQcounter(i),
							loadoffset => LoadMuxedQCounterOffset(i),	--
							readoffset => ReadMuxedQCounterOffset(i),	--
							timestamp => MuxedTimeStampBus,
							indexmask => MuxedIndexMask(i),
							filterrate => MuxedQCountFilterRate,
							clk =>	clklow
							);
					end generate makemuxedquadcountersio;
				end generate nodpllmuxedqcountersio;
			
				dpllmuxedqcountersio: if HM2DPLLs > 0 generate
					makemuxedquadcountersdio: for i in 0 to MuxedQCounters-1 generate
						qcounterxio: entity work.qcounterdio	--
						generic map (
							buswidth => BusWidth
						)
						port map (
							obus => obus,
							ibus => ibus,
							quada => DemuxedQuadA(i),
							quadb => DemuxedQuadB(i),
							index => DemuxedIndex(i),
							loadccr => LoadMuxedQcounterCCR(i),
							readccr => ReadMuxedQcounterCCR(i),
							readcount => ReadMuxedQcounter(i),
							countclear => LoadMuxedQcounter(i),
							loadoffset => LoadMuxedQCounterOffset(i),	--
							readoffset => ReadMuxedQCounterOffset(i),	--
							timestamp => MuxedTimeStampBus,
							indexmask => MuxedIndexMask(i),
							timer => MuxedQCtrDPLLSampleTime,
							timerenable	=> MuxedQCtrTimerEnable,
							filterrate => MuxedQCountFilterRate,
							clk =>	clklow
							);
					end generate makemuxedquadcountersdio;
				end generate dpllmuxedqcountersio;
			end generate nuseprobe2io;

			useprobe2io: if UseMuxedProbe generate
				nodpllmuxedqcounterspio: if HM2DPLLs = 0 generate
					makemuxedquadcounterspio: for i in 0 to MuxedQCounters-1 generate
						qcounterxio: entity work.qcounterpio	--
						generic map (
							buswidth => BusWidth
						)
						port map (
							obus => obus,
							ibus => ibus,
							quada => DemuxedQuadA(i),
							quadb => DemuxedQuadB(i),
							index => DemuxedIndex(i),
							loadccr => LoadMuxedQcounterCCR(i),
							readccr => ReadMuxedQcounterCCR(i),
							readcount => ReadMuxedQcounter(i),
							countclear => LoadMuxedQcounter(i),
							loadoffset => LoadMuxedQCounterOffset(i),	--
							readoffset => ReadMuxedQCounterOffset(i),	--
							timestamp => MuxedTimeStampBus,
							indexmask => MuxedIndexMask(i),
							probe => MuxedProbe,
							filterrate => MuxedQCountFilterRate,
							clk =>	clklow
							);
					end generate makemuxedquadcounterspio;
				end generate nodpllmuxedqcounterspio;
			
				dpllmuxedqcounterspio: if HM2DPLLs > 0 generate
					makemuxedquadcounterspdio: for i in 0 to MuxedQCounters-1 generate
						qcounterxio: entity work.qcounterpdio	--
						generic map (
							buswidth => BusWidth
						)
						port map (
							obus => obus,
							ibus => ibus,
							quada => DemuxedQuadA(i),
							quadb => DemuxedQuadB(i),
							index => DemuxedIndex(i),
							loadccr => LoadMuxedQcounterCCR(i),
							readccr => ReadMuxedQcounterCCR(i),
							readcount => ReadMuxedQcounter(i),
							countclear => LoadMuxedQcounter(i),
							loadoffset => LoadMuxedQCounterOffset(i),	--
							readoffset => ReadMuxedQCounterOffset(i),	--
							timestamp => MuxedTimeStampBus,
							indexmask => MuxedIndexMask(i),
							probe => MuxedProbe,
							timer => MuxedQCtrDPLLSampleTime,
							timerenable	=> MuxedQCtrTimerEnable,
							filterrate => MuxedQCountFilterRate,
							clk =>	clklow
							);
					end generate makemuxedquadcounterspdio;
				end generate dpllmuxedqcounterspio;
			end generate useprobe2io;
		
			nuseprobe3io: if not UseMuxedProbe generate
				nodpllmuxedqcountersmimio: if HM2DPLLs = 0 generate
					makemuxedquadcountersmimio: for i in 0 to MuxedQCountersMIM-1 generate
						qcounterxio: entity work.qcounterio	--
						generic map (
							buswidth => BusWidth
						)
						port map (
							obus => obus,
							ibus => ibus,
							quada => DemuxedQuadA(i),
							quadb => DemuxedQuadB(i),
							index => DemuxedIndex(i),
							loadccr => LoadMuxedQcounterCCR(i),
							readccr => ReadMuxedQcounterCCR(i),
							readcount => ReadMuxedQcounter(i),
							countclear => LoadMuxedQcounter(i),
							loadoffset => LoadMuxedQCounterOffset(i),	--
							readoffset => ReadMuxedQCounterOffset(i),	--
							timestamp => MuxedTimeStampBus,
							indexmask => DeMuxedIndexMask(i),
							filterrate => MuxedQCountFilterRate,
							clk =>	clklow
							);
					end generate makemuxedquadcountersmimio;
				end generate nodpllmuxedqcountersmimio;
			
				dpllmuxedqcountersmimio: if HM2DPLLs > 0 generate
					makemuxedquadcountersmimdio: for i in 0 to MuxedQCountersMIM-1 generate
						qcounterxio: entity work.qcounterdio	--
						generic map (
							buswidth => BusWidth
						)
						port map (
							obus => obus,
							ibus => ibus,
							quada => DemuxedQuadA(i),
							quadb => DemuxedQuadB(i),
							index => DemuxedIndex(i),
							loadccr => LoadMuxedQcounterCCR(i),
							readccr => ReadMuxedQcounterCCR(i),
							readcount => ReadMuxedQcounter(i),
							countclear => LoadMuxedQcounter(i),
							loadoffset => LoadMuxedQCounterOffset(i),	--
							readoffset => ReadMuxedQCounterOffset(i),	--
							timestamp => MuxedTimeStampBus,
							indexmask => DeMuxedIndexMask(i),
							timer => MuxedQCtrDPLLSampleTime,
							timerenable	=> MuxedQCtrTimerEnable,
							filterrate => MuxedQCountFilterRate,
							clk =>	clklow
							);
					end generate makemuxedquadcountersmimdio;
				end generate dpllmuxedqcountersmimio;
			end generate nuseprobe3io;
	
			useprobe3io: if UseMuxedProbe generate
				nodpllmuxedqcountersmimpio: if HM2DPLLs = 0 generate
					makemuxedquadcountersmimpio: for i in 0 to MuxedQCountersMIM-1 generate
						qcounterxio: entity work.qcounterpio	--
						generic map (
							buswidth => BusWidth
						)
						port map (
							obus => obus,
							ibus => ibus,
							quada => DemuxedQuadA(i),
							quadb => DemuxedQuadB(i),
							index => DemuxedIndex(i),
							loadccr => LoadMuxedQcounterCCR(i),
							readccr => ReadMuxedQcounterCCR(i),
							readcount => ReadMuxedQcounter(i),
							countclear => LoadMuxedQcounter(i),
							loadoffset => LoadMuxedQCounterOffset(i),	--
							readoffset => ReadMuxedQCounterOffset(i),	--
							timestamp => MuxedTimeStampBus,
							indexmask => DeMuxedIndexMask(i),
							probe => MuxedProbe,
							filterrate => MuxedQCountFilterRate,
							clk =>	clklow
							);
					end generate makemuxedquadcountersmimpio;
				end generate nodpllmuxedqcountersmimpio;
			
				dpllmuxedqcountersmimpio: if HM2DPLLs > 0 generate
					makemuxedquadcountersmimpdio: for i in 0 to MuxedQCountersMIM-1 generate
						qcounterxio: entity work.qcounterpdio	--
						generic map (
							buswidth => BusWidth
						)
						port map (
							obus => obus,
							ibus => ibus,
							quada => DemuxedQuadA(i),
							quadb => DemuxedQuadB(i),
							index => DemuxedIndex(i),
							loadccr => LoadMuxedQcounterCCR(i),
							readccr => ReadMuxedQcounterCCR(i),
							readcount => ReadMuxedQcounter(i),
							countclear => LoadMuxedQcounter(i),
							loadoffset => LoadMuxedQCounterOffset(i),	--
							readoffset => ReadMuxedQCounterOffset(i),	--
							timestamp => MuxedTimeStampBus,
							indexmask => DeMuxedIndexMask(i),
							probe => MuxedProbe,
							timer => MuxedQCtrDPLLSampleTime,
							timerenable	=> MuxedQCtrTimerEnable,
							filterrate => MuxedQCountFilterRate,
							clk =>	clklow
							);
					end generate makemuxedquadcountersmimpdio;
				end generate dpllmuxedqcountersmimpio;
			end generate useprobe3io;
			
			MuxedQCounterIODecodeProcess : process (A,Readstb,writestb,MuxedQCounterSel, MuxedQCounterCCRSel, MuxedQCounterOffsetSel)
			begin
				if A(15 downto 8) = MuxedQCounterAddr then	 --  QCounter select
					MuxedQCounterSel <= '1';
				else
					MuxedQCounterSel <= '0';
				end if;
				if ((A(15 downto 8) = MuxedQCounterCCRAddr) and (A(7) = '0')) then	 --  QCounter CCR register select
					MuxedQCounterCCRSel <= '1';
				else
					MuxedQCounterCCRSel <= '0';
				end if;
				if ((A(15 downto 8) = MuxedQCounterCCRAddr) and (A(7) = '1')) then	 --  QCounter Index Offset register select
					MuxedQCounterOffsetSel <= '1';
				else
					MuxedQCounterOffsetSel <= '0';
				end if;
				if A(15 downto 8) = MuxedTSDivAddr and writestb = '1' then	 --  
					LoadMuxedTSDiv <= '1';
				else
					LoadMuxedTSDiv <= '0';
				end if;
				if A(15 downto 8) = MuxedTSDivAddr and readstb = '1' then	 --  
					ReadMuxedTSDiv <= '1';
				else
					ReadMuxedTSDiv <= '0';
				end if;
				if A(15 downto 8) = MuxedTSAddr and readstb = '1' then	 --  
					ReadMuxedTS <= '1';
				else
					ReadMuxedTS <= '0';
				end if;
				if A(15 downto 8) = MuxedQCRateAddr and writestb = '1' then	 --  
					LoadMuxedQCountRate <= '1';
				else
					LoadMuxedQCountRate <= '0';
				end if;
				if A(15 downto 8) = MuxedQCTimerSelectAddr and writestb = '1' then	 --  
					LoadMuxedQCtrTimerSelect <= '1';
				else
					LoadMuxedQCtrTimerSelect <= '0';
				end if;
				if A(15 downto 8) = MuxedQCTimerSelectAddr and readstb = '1' then	 --  
					ReadMuxedQCtrTimerSelect <= '1';
				else
					ReadMuxedQCtrTimerSelect <= '0';
				end if;		

				LoadMuxedQCounter <= OneOfNDecode(MuxedQCounters,MuxedQCounterSel,writestb,A(6 downto 2));  -- 32 max
				ReadMuxedQCounter <= OneOfNDecode(MuxedQCounters,MuxedQCounterSel,Readstb,A(6 downto 2));
				LoadMuxedQCounterCCR <= OneOfNDecode(MuxedQCounters,MuxedQCounterCCRSel,writestb,A(6 downto 2));
				ReadMuxedQCounterCCR <= OneOfNDecode(MuxedQCounters,MuxedQCounterCCRSel,Readstb,A(6 downto 2));
				LoadMuxedQCounterOffset <= OneOfNDecode(MuxedQCounters,MuxedQCounterOffsetSel,writestb,A(6 downto 2));
				ReadMuxedQCounterOffset <= OneOfNDecode(MuxedQCounters,MuxedQCounterOffsetSel,Readstb,A(6 downto 2));
			end process MuxedQCounterIODecodeProcess;

		DoMuxedQCounterPins: process(IOBits,MuxedQCtrSel)
		begin	
			for i in 0 to IOWidth -1 loop				-- loop through all the external I/O pins 
				if ThePinDesc(i)(15 downto 8) = MuxedQCountTag then											
					case (ThePinDesc(i)(7 downto 0)) is	--secondary pin function
						when MuxedQCountQAPin =>
							MuxedQuadA(conv_integer(ThePinDesc(i)(23 downto 16))) <= IOBits(i); 
						when MuxedQCountQBPin =>
							MuxedQuadB(conv_integer(ThePinDesc(i)(23 downto 16))) <= IOBits(i);
						when MuxedQCountIdxPin =>
							MuxedIndex(conv_integer(ThePinDesc(i)(23 downto 16))) <= IOBits(i);
						when MuxedQCountIdxMaskPin =>
							MuxedIndexMask(conv_integer(ThePinDesc(i)(23 downto 16))) <= IOBits(i);
						when MuxedQCountProbePin =>
							MuxedProbe <= IOBits(i); -- only 1 please!
						when others => null;
					end case;
				end if;
				if ThePinDesc(i)(15 downto 8) = MuxedQCountSelTag then
					case(ThePinDesc(i)(7 downto 0)) is	--secondary pin function
						when MuxedQCountSel0Pin =>
							AltData(i) <= MuxedQCtrSel(0);
						when MuxedQCountSel1Pin =>
							AltData(i) <= MuxedQCtrSel(1);
						when others => null;
					end case;
				end if;
			end loop;
		end process;
		
		EncoderDeMux: process(clklow)
		begin
			if rising_edge(clklow) then
				if TwoxMuxedQCountFilterRate = '1' then
					PrePreMuxedQCtrSel <= PrePreMuxedQCtrSel + 1;
				end if;
				PreMuxedQCtrSel <= PrePreMuxedQCtrSel;
				MuxedQCtrSel <= PreMuxedQCtrSel;		-- the external mux pin
				MuxedQCtrSampleTime <= PreMuxedQCtrSampleTime;	
				for i in 0 to ((MuxedQCounters/2) -1) loop -- just 2 deep for now
					if PreMuxedQCtrSampleTime(0) = '1' and MuxedQCtrSampleTime(0) = '0' then	-- latch the even inputs	
						DeMuxedQuadA(2*i) <= MuxedQuadA(i);
						DeMuxedQuadB(2*i) <= MuxedQuadB(i);
						DeMuxedIndex(2*i) <= MuxedIndex(i);		
					end if;
					if PreMuxedQCtrSampleTime(0) = '0' and MuxedQCtrSampleTime(0) = '1' then	-- latch the odd inputs
						DeMuxedQuadA(2*i+1) <= MuxedQuadA(i);
						DeMuxedQuadB(2*i+1) <= MuxedQuadB(i);
						DeMuxedIndex(2*i+1) <= MuxedIndex(i);
					end if;
				end loop;
				if PreMuxedQCtrSampleTime(0) = '0' and MuxedQCtrSampleTime(0) = '1' then	-- latch the odd inputs
					MuxedQCountFilterRate <='1';	
				else
					MuxedQCountFilterRate <='0';
				end if;
			end if; -- clk
		end process;		

	end generate makemuxedqcounters;
