NetBurner 3.5.7
PDF Version
gpt.h
1/*NB_REVISION*/
2
3/*NB_COPYRIGHT*/
4
5#ifndef __GPT_H
6#define __GPT_H
7
8#include <predef.h>
9#include <stdint.h>
10#include <stddef.h>
11#include <sim.h>
12
13enum GPT_Clk
14{
15 GPT_CLK_OFF = 0u,
16 GPT_CLK_PERIPH = 1u,
17 GPT_CLK_HF_REF = 2u,
18 GPT_CLK_EXT = 3u,
19 GPT_CLK_LF_REF = 4u,
20 GPT_CLK_XO = 5u,
21};
22
23enum GPT_CapCh
24{
25 GPT_CAP_CH1 = 0u,
26 GPT_CAP_CH2 = 1u
27};
28
29enum GPT_CapEdge
30{
31 GPT_CAP_NONE = 0u,
32 GPT_CAP_RISING = 1u,
33 GPT_CAP_FALLING = 2u,
34 GPT_CAP_BOTH = 3u,
35};
36
37enum GPT_CompCh
38{
39 GPT_COMP_CH1 = 0u,
40 GPT_COMP_CH2 = 1u,
41 GPT_COMP_CH3 = 2u,
42};
43
44enum GPT_OutMode
45{
46 GPT_OUT_NONE = 0u,
47 GPT_OUT_TGL = 1u,
48 GPT_OUT_CLR = 2u,
49 GPT_OUT_SET = 3u,
50 GPT_OUT_LOW_PULSE = 4u,
51};
52
53
54const uint32_t GPT_STATUS_ROV=(32);
55const uint32_t GPT_STATUS_IF2=(16);
56const uint32_t GPT_STATUS_IF1=(8);
57const uint32_t GPT_STATUS_OF3=(4);
58const uint32_t GPT_STATUS_OF2=(2);
59const uint32_t GPT_STATUS_OF1=(1);
60
61
62class GPTimer : private GPT_Type
63{
64 struct ctx_t
65 {
66 void (*irqCB)(GPTimer *);
67 uint32_t irqCount;
68 };
69 static ctx_t sCtxs[2];
70 static ctx_t *sGetCtx(GPTimer *timer)
71 {
72 switch ((uint32_t)timer) {
73 case GPT1_BASE: return sCtxs + 0;
74 case GPT2_BASE: return sCtxs + 1;
75 }
76 return NULL;
77 }
78
79 GPTimer();
80 void isr();
81
82 friend void irq_gpt1();
83 friend void irq_gpt2();
84public:
85 static inline GPTimer *GPT(GPT_Type *gpt);
86
87 void Init(uint32_t div, bool freeRun, bool restartFromZero, GPT_Clk clk = GPT_CLK_PERIPH);
88
89 inline void Reset();
90 void ResetCount();
91 inline void SetClkSrc(GPT_Clk clk);
92 inline GPT_Clk GetClkSrc();
93 inline void SetClkDiv(uint32_t div);
94 inline uint32_t GetClkDiv();
95 inline void SetOscClkDiv(uint32_t divider);
96 inline uint32_t GetOscClkDiv();
97 inline void Start();
98 inline void Stop();
99 inline uint32_t GetCurCount();
100 inline void SetCapEdge(GPT_CapCh ch, GPT_CapEdge edge);
101 inline GPT_CapEdge GetCapEdge(GPT_CapCh ch);
102 inline uint32_t GetCapVal(GPT_CapCh ch);
103 inline void SetOutMode(GPT_CompCh ch, GPT_OutMode mode);
104 inline GPT_OutMode GetOutMode(GPT_CompCh ch);
105 inline void SetCompVal(GPT_CompCh ch, uint32_t val);
106 inline uint32_t GetCompVal(GPT_CompCh ch);
107 inline void ForceOutput(GPT_CompCh ch);
108 inline void EnableIRQ(uint32_t mask);
109 inline void DisableIRQ(uint32_t mask);
110 inline uint32_t GetEnabledIRQ();
111 inline uint32_t GetStatus(uint32_t flags = 0xFFFFFFFF);
112 inline void ClrIRQ(uint32_t flags);
113
114 inline void SetIRQFn( void (*fn)(GPTimer *) );
115 inline uint32_t GetIRQCount();
116};
117
118inline GPTimer *GPTimer::GPT(GPT_Type *gpt)
119{
120 return (GPTimer*)(gpt);
121}
122
123inline void GPTimer::
124Reset()
125{
126 CR |= GPT_CR_SWR_MASK; while((CR & GPT_CR_SWR_MASK));
127}
128
129inline void GPTimer::
130SetClkSrc(GPT_Clk clk)
131{
132 CR = (CR & ~(GPT_CR_CLKSRC_MASK | GPT_CR_EN_24M_MASK))
133 | GPT_CR_CLKSRC(clk)
134 | ((clk == GPT_CLK_XO) ? GPT_CR_EN_24M_MASK : 0);
135}
136
137inline GPT_Clk GPTimer::
138GetClkSrc()
139{
140 return (GPT_Clk)((CR & GPT_CR_CLKSRC_MASK) >> GPT_CR_CLKSRC_SHIFT);
141}
142
143inline void GPTimer::
144SetClkDiv(uint32_t div)
145{
146 PR = (PR & ~GPT_PR_PRESCALER_MASK) | GPT_PR_PRESCALER(div - 1U);
147}
148
149inline uint32_t GPTimer::
150GetClkDiv()
151{
152 return ((PR & GPT_PR_PRESCALER_MASK) >> GPT_PR_PRESCALER_SHIFT) + 1U;
153}
154
155inline void GPTimer::
156SetOscClkDiv(uint32_t divider)
157{
158 PR = (PR & ~GPT_PR_PRESCALER24M_MASK) | GPT_PR_PRESCALER24M(divider - 1U);
159}
160
161inline uint32_t GPTimer::
162GetOscClkDiv()
163{
164 return ((PR & GPT_PR_PRESCALER24M_MASK) >> GPT_PR_PRESCALER24M_SHIFT) + 1U;
165}
166
167inline void GPTimer::
168Start()
169{
170 CR |= GPT_CR_EN_MASK;
171}
172
173inline void GPTimer::
174Stop()
175{
176 CR &= ~GPT_CR_EN_MASK;
177}
178
179inline uint32_t GPTimer::
180GetCurCount()
181{
182 return CNT;
183}
184
185inline void GPTimer::
186SetCapEdge(GPT_CapCh ch, GPT_CapEdge edge)
187{
188 CR = (CR & ~(GPT_CR_IM1_MASK << ((uint32_t)ch * 2UL)))
189 | (GPT_CR_IM1(edge) << ((uint32_t)ch * 2UL));
190}
191
192inline GPT_CapEdge GPTimer::
193GetCapEdge(GPT_CapCh ch)
194{
195 return (GPT_CapEdge)(uint8_t)
196 ((CR >> (GPT_CR_IM1_SHIFT + (uint32_t)ch * 2UL))
197 & (GPT_CR_IM1_MASK >> GPT_CR_IM1_SHIFT));
198}
199
200inline uint32_t GPTimer::
201GetCapVal(GPT_CapCh ch)
202{
203 return ICR[ch];
204}
205
206inline void GPTimer::
207SetOutMode(GPT_CompCh ch, GPT_OutMode mode)
208{
209 CR = (CR & ~(GPT_CR_OM1_MASK << ((uint32_t)ch * 3UL)))
210 | (GPT_CR_OM1(mode) << ((uint32_t)ch * 3UL));
211}
212
213inline GPT_OutMode GPTimer::
214GetOutMode(GPT_CompCh ch)
215{
216 return (GPT_OutMode)(uint8_t)
217 ((CR >> (GPT_CR_OM1_SHIFT + (uint32_t)ch * 3UL))
218 & (GPT_CR_OM1_MASK >> GPT_CR_OM1_SHIFT));
219}
220
221inline void GPTimer::
222SetCompVal(GPT_CompCh ch, uint32_t val)
223{
224 OCR[ch] = val;
225}
226
227inline uint32_t GPTimer::
228GetCompVal(GPT_CompCh ch)
229{
230 return OCR[ch];
231}
232
233inline void GPTimer::
234ForceOutput(GPT_CompCh ch)
235{
236 CR |= (GPT_CR_FO1_MASK << (uint32_t)ch);
237}
238
239inline void GPTimer::
240EnableIRQ(uint32_t mask)
241{
242 IR |= mask;
243}
244
245inline void GPTimer::
246DisableIRQ(uint32_t mask)
247{
248 IR &= ~mask;
249}
250
251inline uint32_t GPTimer::
252GetEnabledIRQ()
253{
254 return IR;
255}
256
257inline uint32_t GPTimer::
258GetStatus(uint32_t flags)
259{
260 return SR & flags;
261}
262
263inline void GPTimer::
264ClrIRQ(uint32_t flags)
265{
266 SR = flags;
267 asm("dsb");
268}
269
270inline void GPTimer::
271SetIRQFn( void (*fn)(GPTimer *) )
272{
273 GPTimer::ctx_t *ctx = sGetCtx(this);
274 if (ctx) { ctx->irqCB = fn; }
275}
276
277inline uint32_t GPTimer::
278GetIRQCount()
279{
280 GPTimer::ctx_t *ctx = sGetCtx(this);
281 if (ctx) { return ctx->irqCount; }
282 return 0;
283}
284
285
286
287#endif /* ----- #ifndef __GPT_H ----- */