← Back to branch summary

~arcachofo/simulide/1.1.0

« back to all changes in this revision

Viewing changes to src/gpsim/modules/clc.h

  • Committer: arcachofo
  • Date: 2021-01-01 14:23:42 UTC
  • Revision ID: arcachofo@simulide.com-20210101142342-ozfljnll44g5lbl3
Initial Commit 0.5.15-RC3

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gpsim/modules/clc.h
 
1
/*
 
2
   Copyright (C) 2017 Roy R Rankin
 
3
 
 
4
This file is part of the libgpsim library of gpsim
 
5
 
 
6
This library is free software; you can redistribute it and/or
 
7
modify it under the terms of the GNU Lesser General Public
 
8
License as published by the Free Software Foundation; either
 
9
version 2.1 of the License, or (at your option) any later version.
 
10
 
 
11
This library is distributed in the hope that it will be useful,
 
12
but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
14
Lesser General Public License for more details.
 
15
 
 
16
You should have received a copy of the GNU Lesser General Public
 
17
License along with this library; if not, see 
 
18
<http://www.gnu.org/licenses/lgpl-2.1.html>.
 
19
*/
 
20
/****************************************************************
 
21
*                                                               *
 
22
*  Modified 2018 by Santiago Gonzalez    santigoro@gmail.com    *
 
23
*                                                               *
 
24
*****************************************************************/
 
25
 
 
26
// CONFIGURABLE LOGIC CELL (CLC)
 
27
 
 
28
#ifndef __CLC_h__
 
29
#define __CLC_h__
 
30
 
 
31
#include "registers.h"
 
32
#include "apfcon.h"
 
33
 
 
34
class CLC;
 
35
class OSC_SIM;
 
36
class NCO;
 
37
class INxSignalSink;
 
38
class CLCSigSource;
 
39
 
 
40
class CLCxCON : public SfrReg
 
41
{
 
42
public:
 
43
    CLCxCON(CLC *_clc, Processor *pCpu, const char *pName) :
 
44
        SfrReg(pCpu, pName), m_clc(_clc), write_mask(0xdf)
 
45
    {
 
46
    }
 
47
    void put(uint);
 
48
 
 
49
private:
 
50
    CLC *m_clc;
 
51
    uint write_mask;
 
52
};
 
53
 
 
54
class CLCxPOL : public SfrReg
 
55
{
 
56
public:
 
57
    CLCxPOL(CLC *_clc, Processor *pCpu, const char *pName  ) :
 
58
        SfrReg(pCpu, pName  ), m_clc(_clc), write_mask(0x8f)
 
59
 
 
60
    {
 
61
    }
 
62
 
 
63
    void put(uint);
 
64
 
 
65
private:
 
66
    CLC *m_clc;
 
67
    uint write_mask;
 
68
};
 
69
 
 
70
class CLCxSEL0 : public SfrReg
 
71
{
 
72
public:
 
73
    CLCxSEL0(CLC *_clc, Processor *pCpu, const char *pName  );
 
74
 
 
75
    void put(uint);
 
76
 
 
77
private:
 
78
    CLC *m_clc;
 
79
    uint write_mask;
 
80
    
 
81
};
 
82
 
 
83
class CLCxSEL1 : public SfrReg
 
84
{
 
85
public:
 
86
    CLCxSEL1(CLC *_clc, Processor *pCpu, const char *pName  );
 
87
    void put(uint);
 
88
 
 
89
private:
 
90
    CLC *m_clc;
 
91
    uint write_mask;
 
92
};
 
93
 
 
94
class CLCxGLS0 : public SfrReg
 
95
{
 
96
public:
 
97
    CLCxGLS0(CLC *_clc, Processor *pCpu, const char *pName  ) :
 
98
        SfrReg(pCpu, pName  ), m_clc(_clc)
 
99
    {
 
100
    }
 
101
 
 
102
    void put(uint);
 
103
 
 
104
private:
 
105
    CLC *m_clc;
 
106
};
 
107
 
 
108
class CLCxGLS1 : public SfrReg
 
109
{
 
110
public:
 
111
    CLCxGLS1(CLC *_clc, Processor *pCpu, const char *pName  ) :
 
112
        SfrReg(pCpu, pName  ), m_clc(_clc)
 
113
 
 
114
    {
 
115
    }
 
116
 
 
117
    void put(uint);
 
118
 
 
119
private:
 
120
    CLC *m_clc;
 
121
};
 
122
 
 
123
class CLCxGLS2 : public SfrReg
 
124
{
 
125
public:
 
126
    CLCxGLS2(CLC *_clc, Processor *pCpu, const char *pName  ) :
 
127
        SfrReg(pCpu, pName  ), m_clc(_clc)
 
128
 
 
129
    {
 
130
    }
 
131
 
 
132
    void put(uint);
 
133
 
 
134
private:
 
135
    CLC *m_clc;
 
136
};
 
137
 
 
138
class CLCxGLS3 : public SfrReg
 
139
{
 
140
public:
 
141
    CLCxGLS3(CLC *_clc, Processor *pCpu, const char *pName  ) :
 
142
        SfrReg(pCpu, pName  ), m_clc(_clc)
 
143
 
 
144
    {
 
145
    }
 
146
 
 
147
    void put(uint);
 
148
 
 
149
private:
 
150
    CLC *m_clc;
 
151
};
 
152
 
 
153
class CLCDATA : public SfrReg
 
154
{
 
155
public:
 
156
    CLCDATA(Processor *pCpu, const char *pName = 0 ) :
 
157
        SfrReg(pCpu, pName  )
 
158
    {
 
159
        for(int i = 0; i < 4; i++)
 
160
            m_clc[i] = 0;
 
161
    }
 
162
 
 
163
 
 
164
    void put(uint val){;}
 
165
    void set_bit(bool bit_val, uint pos);
 
166
    void set_clc(CLC *clc1, CLC *clc2=0, CLC *clc3=0, CLC *clc4 = 0)
 
167
    {
 
168
        m_clc[0] = clc1;
 
169
        m_clc[1] = clc2;
 
170
        m_clc[2] = clc3;
 
171
        m_clc[3] = clc4;
 
172
    }
 
173
 
 
174
private:
 
175
    CLC *m_clc[4];
 
176
};
 
177
 
 
178
class CLC : public apfpin
 
179
{
 
180
public:
 
181
    CLC(Processor *_cpu, uint _index, CLCDATA *_clcdata);
 
182
    ~CLC();
 
183
 
 
184
    enum {
 
185
        // CLCxCON
 
186
        LCxEN   = (1<<7),
 
187
        LCxOE   = (1<<6),
 
188
        LCxOUT  = (1<<5),
 
189
        LCxINTP = (1<<4),
 
190
        LCxINTN = (1<<3),
 
191
        LCxMODE = 0x7,
 
192
 
 
193
        // CLCxPOL
 
194
        LCxPOL  = (1<<7),
 
195
    };
 
196
    enum data_in {
 
197
        UNUSED = 0,
 
198
        LC1,
 
199
        LC2,
 
200
        LC3,
 
201
        LC4,
 
202
        CLCxIN0,    // 5
 
203
        CLCxIN1,
 
204
        PWM1,
 
205
        PWM2,
 
206
        PWM3,
 
207
        PWM4,        //10
 
208
        NCOx,
 
209
        FOSCLK,
 
210
        LFINTOSC,
 
211
        HFINTOSC,
 
212
        FRC_IN,        //15
 
213
        T0_OVER,
 
214
        T1_OVER,
 
215
        T2_MATCH,
 
216
        C1OUT,
 
217
        C2OUT,        //20
 
218
    };
 
219
    
 
220
    enum {
 
221
        CLCout_PIN=0,
 
222
        CLCin1_PIN,
 
223
        CLCin2_PIN
 
224
    };
 
225
 
 
226
    bool CLCenabled() { return clcxcon.value.get() & LCxEN; }
 
227
    void setCLCxPin( PinModule *alt_pin );
 
228
    void enableINxpin( int, bool );
 
229
    virtual void setIOpin( int data, PinModule *pin );
 
230
    virtual void D1S( int select );
 
231
    virtual void D2S( int select );
 
232
    virtual void D3S( int select );
 
233
    virtual void D4S( int select );
 
234
    void t0_overflow();
 
235
    void t1_overflow();
 
236
    void t2_match();
 
237
    void osc_out( bool level, int kind );
 
238
    void out_pwm( bool level, int id );
 
239
    void NCO_out( bool level );
 
240
    void CxOUT_sync(bool output, int cm);
 
241
    void set_clcPins(PinModule *IN0, PinModule *IN1, PinModule *_CLCx)
 
242
    { pinCLCxIN[0] = IN0; pinCLCxIN[1] = IN1, pinCLCx = _CLCx;}
 
243
    void setState(char new3State, int index);
 
244
    void releasePinSource(PinModule *pin);
 
245
    void oeCLCx(bool on);
 
246
    void update_clccon(uint diff);
 
247
    void config_inputs(bool on);
 
248
    void compute_gates();
 
249
    void cell_function();
 
250
    bool cell_1_in_flipflop();
 
251
    bool cell_2_in_flipflop();
 
252
    bool cell_sr_latch();
 
253
    bool JKflipflop();
 
254
    bool transparent_D_latch();
 
255
    void lcxupdate(bool bit_val, uint pos);
 
256
    virtual void setInterruptSource(InterruptSource * _int)
 
257
    { m_Interrupt = _int;}
 
258
    void outputCLC(bool out);
 
259
 
 
260
    uint  index;
 
261
    CLCxCON  clcxcon;
 
262
    CLCxPOL  clcxpol;
 
263
    CLCxSEL0 clcxsel0;
 
264
    CLCxSEL1 clcxsel1;
 
265
    CLCxGLS0 clcxgls0;
 
266
    CLCxGLS1 clcxgls1;
 
267
    CLCxGLS2 clcxgls2;
 
268
    CLCxGLS3 clcxgls3;
 
269
    CLCDATA  *clcdata;
 
270
    OSC_SIM  *frc;
 
271
    OSC_SIM  *lfintosc;
 
272
    OSC_SIM  *hfintosc;
 
273
    NCO      *p_nco;
 
274
    data_in      DxS_data[4];
 
275
 
 
276
private:
 
277
    PinModule     *pinCLCx;
 
278
    CLCSigSource  *CLCxsrc;
 
279
    string        CLCxgui;
 
280
    bool          srcCLCxactive;
 
281
    INxSignalSink *INxsink[2];
 
282
    int          INxactive[2];
 
283
    bool      INxstate[2];
 
284
    PinModule     *pinCLCxIN[2];
 
285
    string        INxgui[2];
 
286
    bool      pwmx_level[4];
 
287
    bool      CMxOUT_level[4];
 
288
    bool      frc_level;
 
289
    bool      NCO_level;
 
290
    bool      lcxdT[4];        // incoming data
 
291
    bool      lcxg[4];        // Data gate output
 
292
    InterruptSource *m_Interrupt;
 
293
    bool      Doutput;
 
294
    bool      Dclock;
 
295
    bool      FRCactive;
 
296
    bool      LFINTOSCactive;
 
297
    bool      HFINTOSCactive;
 
298
};
 
299
 
 
300
class CLC1 : public CLC
 
301
{
 
302
public:
 
303
    CLC1( Processor* _cpu, uint _index, CLCDATA* _clcdata );
 
304
 
 
305
    virtual void D1S(int select);
 
306
    virtual void D2S(int select);
 
307
    virtual void D3S(int select);
 
308
    virtual void D4S(int select);
 
309
 
 
310
private:
 
311
    void setDxsData( int select, int i );
 
312
};
 
313
 
 
314
// RC clock 600KHz used with ADC, CLC
 
315
class OSC_SIM : public TriggerObject
 
316
{
 
317
public:
 
318
    OSC_SIM( double _freq, int _data_in , Processor* cpu );
 
319
 
 
320
    void start_osc_sim(bool on);
 
321
 
 
322
    void set_clc(CLC *clc1, CLC *clc2=0, CLC *clc3=0, CLC *clc4 = 0)
 
323
    {
 
324
        m_clc[0] = clc1; m_clc[1] = clc2; m_clc[2] = clc3; m_clc[3] = clc4;
 
325
    }
 
326
    void callback();
 
327
 
 
328
private:
 
329
    double  frequency;
 
330
    int     data_in;
 
331
    int      active;
 
332
    CLC*  m_clc[4];
 
333
    bool     level;
 
334
    int      next_cycle;
 
335
    uint64_t future_cycle;
 
336
    int64_t  adjust_cycles;
 
337
};
 
338
#endif // __CLC_h__