OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [rtos/] [ecos-2.0/] [packages/] [kernel/] [v2_0/] [include/] [clock.hxx] - Blame information for rev 332

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 27 unneback
#ifndef CYGONCE_KERNEL_CLOCK_HXX
2
#define CYGONCE_KERNEL_CLOCK_HXX
3
 
4
//==========================================================================
5
//
6
//      clock.hxx
7
//
8
//      Clock and Alarm class declaration(s)
9
//
10
//==========================================================================
11
//####ECOSGPLCOPYRIGHTBEGIN####
12
// -------------------------------------------
13
// This file is part of eCos, the Embedded Configurable Operating System.
14
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.
15
//
16
// eCos is free software; you can redistribute it and/or modify it under
17
// the terms of the GNU General Public License as published by the Free
18
// Software Foundation; either version 2 or (at your option) any later version.
19
//
20
// eCos is distributed in the hope that it will be useful, but WITHOUT ANY
21
// WARRANTY; without even the implied warranty of MERCHANTABILITY or
22
// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
23
// for more details.
24
//
25
// You should have received a copy of the GNU General Public License along
26
// with eCos; if not, write to the Free Software Foundation, Inc.,
27
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
28
//
29
// As a special exception, if other files instantiate templates or use macros
30
// or inline functions from this file, or you compile this file and link it
31
// with other works to produce a work based on this file, this file does not
32
// by itself cause the resulting work to be covered by the GNU General Public
33
// License. However the source code for this file must still be made available
34
// in accordance with section (3) of the GNU General Public License.
35
//
36
// This exception does not invalidate any other reasons why a work based on
37
// this file might be covered by the GNU General Public License.
38
//
39
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.
40
// at http://sources.redhat.com/ecos/ecos-license/
41
// -------------------------------------------
42
//####ECOSGPLCOPYRIGHTEND####
43
//==========================================================================
44
//#####DESCRIPTIONBEGIN####
45
//
46
// Author(s):   nickg
47
// Contributors:        nickg
48
// Date:        1997-09-09
49
// Purpose:     Define Clock and Alarm class interfaces
50
// Description: The classes defined here collectively implement the
51
//              internal API used to create, configure and manage Counters,
52
//              Clocks and Alarms.
53
// Usage:       #include 
54
//
55
//####DESCRIPTIONEND####
56
//
57
//==========================================================================
58
 
59
#include 
60
#include             // assertion macros
61
 
62
#include 
63
 
64
// -------------------------------------------------------------------------
65
// Forward definitions and typedefs.
66
 
67
class Cyg_Alarm;
68
 
69
typedef void cyg_alarm_fn(Cyg_Alarm *alarm, CYG_ADDRWORD data);
70
 
71
typedef Cyg_CList_T Cyg_Alarm_List;
72
 
73
// -------------------------------------------------------------------------
74
// Counter object.
75
 
76
class Cyg_Counter
77
{
78
 
79
    friend class Cyg_Alarm;
80
 
81
#if defined(CYGIMP_KERNEL_COUNTERS_SINGLE_LIST)
82
 
83
    Cyg_Alarm_List      alarm_list;     // Linear list of Alarms
84
 
85
#elif defined(CYGIMP_KERNEL_COUNTERS_MULTI_LIST)
86
 
87
    Cyg_Alarm_List      alarm_list[CYGNUM_KERNEL_COUNTERS_MULTI_LIST_SIZE];
88
 
89
#endif
90
 
91
    volatile cyg_tick_count counter;    // counter value
92
 
93
    cyg_uint32          increment;      // increment per tick
94
 
95
public:
96
 
97
    CYGDBG_DEFINE_CHECK_THIS
98
 
99
    Cyg_Counter(
100
        cyg_uint32      increment = 1
101
    );
102
 
103
    ~Cyg_Counter();
104
 
105
    // Return current value of counter
106
    cyg_tick_count current_value();
107
 
108
    // Return low and high halves of the
109
    // counter value.
110
    cyg_uint32 current_value_lo();
111
    cyg_uint32 current_value_hi();
112
 
113
    // Set the counter's current value
114
    void set_value( cyg_tick_count new_value);
115
 
116
    // Advance counter by some number of ticks
117
    void tick( cyg_uint32 ticks = 1);
118
 
119
    // Add an alarm to this counter
120
    void add_alarm( Cyg_Alarm *alarm );
121
 
122
    // Remove an alarm from this counter
123
    void rem_alarm( Cyg_Alarm *alarm );
124
 
125
};
126
 
127
// -------------------------------------------------------------------------
128
// Clock class. This is derived from a Counter and defines extra
129
// features to support clock-like behaviour.
130
 
131
class Cyg_Clock
132
    : public Cyg_Counter
133
{
134
 
135
public:
136
 
137
    CYGDBG_DEFINE_CHECK_THIS
138
 
139
    // This structure allows a more accurate representation
140
    // of the resolution than a single integer would allow.
141
    // The resolution is defined as dividend/divisor nanoseconds
142
    // per tick.
143
    struct cyg_resolution {
144
        cyg_uint32  dividend;
145
        cyg_uint32  divisor;
146
    };
147
 
148
private:
149
 
150
    cyg_resolution      resolution;     // Current clock resolution
151
 
152
public:
153
 
154
    Cyg_Clock(                          // Create clock with given resolution
155
        cyg_resolution resolution
156
        );
157
 
158
    ~Cyg_Clock();                       // Destructor
159
 
160
    cyg_resolution get_resolution();    // Return current resolution
161
 
162
    void set_resolution(                // Set new resolution
163
        cyg_resolution resolution
164
        );
165
 
166
    // There is a need for converting from "other" ticks to clock ticks.
167
    // We will construct 4 numbers to do the conversion as:
168
    //   clock_ticks = (((otherticks*mul1)/div1)*mul2/div2)
169
    // with the values chosen to minimize the possibility of overflow.
170
    // Do the arithmetic in cyg_uint64s throughout.
171
    struct converter {
172
        cyg_uint64 mul1, div1, mul2, div2;
173
    };
174
 
175
    // There are two of these because the 4 numbers are different depending
176
    // on the direction of the conversion, to prevent loss of significance.
177
    // NB these relate to the resolution of the clock object they are
178
    // called against, not necessarily "the" system real time clock.
179
    void get_other_to_clock_converter( cyg_uint64 ns_per_other_tick,
180
                                       struct converter *pcc );
181
 
182
    void get_clock_to_other_converter( cyg_uint64 ns_per_other_tick,
183
                                       struct converter *pcc );
184
 
185
    // A utility to perform the conversion in the obvious way, with
186
    // rounding to nearest at each stage.  Static because it uses a
187
    // previously acquired converter.
188
    static cyg_tick_count convert( cyg_tick_count value,
189
                                   struct converter *pcc );
190
 
191
#ifdef CYGVAR_KERNEL_COUNTERS_CLOCK
192
 
193
    // There is a system supplied real time clock...
194
 
195
    static Cyg_Clock *real_time_clock;
196
 
197
#endif
198
 
199
};
200
 
201
// -------------------------------------------------------------------------
202
// Alarm class. An alarm may be attached to a counter (or a clock) to be
203
// called when the trigger value is reached.
204
 
205
class Cyg_Alarm
206
#if defined(CYGIMP_KERNEL_COUNTERS_SINGLE_LIST) || defined(CYGIMP_KERNEL_COUNTERS_MULTI_LIST)
207
    : public Cyg_DNode_T
208
#endif
209
{
210
    friend class Cyg_Counter;
211
 
212
protected:
213
    Cyg_Counter         *counter;       // Attached to this counter/clock
214
 
215
    cyg_alarm_fn        *alarm;         // Call-back function
216
 
217
    CYG_ADDRWORD        data;           // Call-back data
218
 
219
    cyg_tick_count      trigger;        // Absolute trigger time
220
 
221
    cyg_tick_count      interval;       // Retrigger interval
222
 
223
    cyg_bool            enabled;        // True if enabled
224
 
225
    Cyg_Alarm();
226
 
227
    void synchronize( void );           // deal with times in the past,
228
                                        // make next alarm in synch.
229
 
230
public:
231
 
232
    CYGDBG_DEFINE_CHECK_THIS
233
 
234
    Cyg_Alarm                           // Constructor
235
    (
236
        Cyg_Counter     *counter,       // Attached to this counter
237
        cyg_alarm_fn    *alarm,         // Call-back function
238
        CYG_ADDRWORD    data            // Call-back data
239
        );
240
 
241
    ~Cyg_Alarm();                       // Destructor
242
 
243
    void initialize(                    // Initialize Alarm
244
        cyg_tick_count    trigger,      // Absolute trigger time
245
        cyg_tick_count    interval = 0  // Relative retrigger interval
246
        );
247
 
248
    void enable();                      // Ensure alarm enabled
249
 
250
    void disable();                     // Ensure alarm disabled
251
 
252
    void get_times(
253
        cyg_tick_count  *trigger,       // Next trigger time
254
        cyg_tick_count  *interval       // Current interval
255
        );
256
};
257
 
258
// -------------------------------------------------------------------------
259
 
260
#endif // ifndef CYGONCE_KERNEL_CLOCK_HXX
261
// EOF clock.hxx

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.