source: rtems/c/src/lib/libbsp/shared/tod.c @ 2e92a5d

4.104.115
Last change on this file since 2e92a5d was 7e0bd6e, checked in by Joel Sherrill <joel.sherrill@…>, on 05/27/09 at 14:21:29

2009-05-27 Sebastian Huber <sebastian.huber@…>

  • tod.h, tod.c: Update for new RTC driver interface.
  • Property mode set to 100644
File size: 5.9 KB
Line 
1/*
2 *  Real Time Clock Driver Wrapper for Libchip
3 *
4 *  The license and distribution terms for this file may be
5 *  found in the file LICENSE in this distribution or at
6 *  http://www.rtems.com/license/LICENSE.
7 *
8 *  $Id$
9 */
10
11#include <rtems.h>
12#include <rtems/rtc.h>
13#include <rtems/libio.h>
14
15#include <libchip/rtc.h>
16
17/*
18 *  Configuration Information
19 */
20
21extern size_t                     RTC_Count;
22extern rtems_device_minor_number  RTC_Minor;
23
24int RTC_Present;
25
26extern void setRealTimeToRTEMS(void);
27
28/*
29 *  rtc_initialize
30 *
31 *  Initialize the RTC driver
32 */
33
34rtems_device_driver rtc_initialize(
35  rtems_device_major_number  major,
36  rtems_device_minor_number  minor_arg,
37  void                      *arg
38)
39{
40  rtems_device_minor_number minor;
41  rtems_status_code status;
42
43  for (minor=0; minor < RTC_Count ; minor++) {
44    /*
45     * First perform the configuration dependent probe, then the
46     * device dependent probe
47     */
48
49    if (RTC_Table[minor].deviceProbe && RTC_Table[minor].deviceProbe(minor)) {
50      /*
51       * Use this device as the primary RTC
52       */
53      RTC_Minor = minor;
54      RTC_Present = 1;
55      break;
56    }
57  }
58
59  if ( !RTC_Present ) {
60    /*
61     * Failed to find an RTC -- this is not a fatal error.
62     */
63
64    return RTEMS_INVALID_NUMBER;
65  }
66
67  /*
68   *  Register and initialize the primary RTC's
69   */
70
71  status = rtems_io_register_name( RTC_DEVICE_NAME, major, RTC_Minor );
72  if (status != RTEMS_SUCCESSFUL) {
73    rtems_fatal_error_occurred(status);
74  }
75
76  RTC_Table[minor].pDeviceFns->deviceInitialize( RTC_Minor );
77
78  /*
79   *  Now initialize any secondary RTC's
80   */
81
82  for ( minor++ ; minor<RTC_Count ; minor++) {
83    /*
84     * First perform the configuration dependent probe, then the
85     * device dependent probe
86     */
87
88    if (RTC_Table[minor].deviceProbe && RTC_Table[minor].deviceProbe(minor)) {
89      status = rtems_io_register_name(
90        RTC_Table[minor].sDeviceName,
91        major,
92        minor );
93      if (status != RTEMS_SUCCESSFUL) {
94        rtems_fatal_error_occurred(status);
95      }
96
97      /*
98       * Initialize the hardware device.
99       */
100
101      RTC_Table[minor].pDeviceFns->deviceInitialize(minor);
102
103    }
104  }
105
106  setRealTimeToRTEMS();
107  return RTEMS_SUCCESSFUL;
108}
109
110rtems_device_driver rtc_read(
111  rtems_device_major_number  major,
112  rtems_device_minor_number  minor,
113  void *arg
114)
115{
116  int rv = 0;
117  rtems_libio_rw_args_t *rw = arg;
118  rtems_time_of_day *tod = (rtems_time_of_day *) rw->buffer;
119
120  rw->offset = 0;
121  rw->bytes_moved = 0;
122
123  if (!RTC_Present) {
124    return RTEMS_NOT_CONFIGURED;
125  }
126
127  if (rw->count != sizeof( rtems_time_of_day)) {
128    return RTEMS_INVALID_SIZE;
129  }
130
131  rv = RTC_Table [RTC_Minor].pDeviceFns->deviceGetTime(
132    RTC_Minor,
133    tod
134  );
135  if (rv != 0) {
136    return RTEMS_IO_ERROR;
137  }
138
139  rw->bytes_moved = rw->count;
140
141  return RTEMS_SUCCESSFUL;
142}
143
144rtems_device_driver rtc_write(
145  rtems_device_major_number  major,
146  rtems_device_minor_number  minor,
147  void *arg
148)
149{
150  int rv = 0;
151  rtems_libio_rw_args_t *rw = arg;
152  const rtems_time_of_day *tod = (const rtems_time_of_day *) rw->buffer;
153
154  rw->offset = 0;
155  rw->bytes_moved = 0;
156
157  if (!RTC_Present) {
158    return RTEMS_NOT_CONFIGURED;
159  }
160
161  if (rw->count != sizeof( rtems_time_of_day)) {
162    return RTEMS_INVALID_SIZE;
163  }
164
165  rv = RTC_Table [RTC_Minor].pDeviceFns->deviceSetTime(
166    RTC_Minor,
167    tod
168  );
169  if (rv != 0) {
170    return RTEMS_IO_ERROR;
171  }
172
173  rw->bytes_moved = rw->count;
174
175  return RTEMS_SUCCESSFUL;
176}
177
178rtems_device_driver rtc_open(
179  rtems_device_major_number major,
180  rtems_device_minor_number minor,
181  void *arg
182)
183{
184  return RTEMS_SUCCESSFUL;
185}
186
187rtems_device_driver rtc_close(
188  rtems_device_major_number major,
189  rtems_device_minor_number minor,
190  void *arg
191)
192{
193  return RTEMS_SUCCESSFUL;
194}
195
196rtems_device_driver rtc_control(
197  rtems_device_major_number major,
198  rtems_device_minor_number minor,
199  void *arg
200)
201{
202  return RTEMS_NOT_IMPLEMENTED;
203}
204
205/*PAGE
206 *
207 *  This routine copies the time from the real time clock to RTEMS
208 *
209 *  Input parameters:  NONE
210 *
211 *  Output parameters:  NONE
212 *
213 *  Return values: NONE
214 */
215
216void setRealTimeToRTEMS()
217{
218  rtems_time_of_day rtc_tod;
219
220  if (!RTC_Present)
221    return;
222
223  RTC_Table[RTC_Minor].pDeviceFns->deviceGetTime(RTC_Minor, &rtc_tod);
224  rtems_clock_set( &rtc_tod );
225}
226
227/*PAGE
228 *
229 *  setRealTimeFromRTEMS
230 *
231 *  This routine copies the time from RTEMS to the real time clock
232 *
233 *  Input parameters:  NONE
234 *
235 *  Output parameters:  NONE
236 *
237 *  Return values: NONE
238 */
239
240void setRealTimeFromRTEMS(void)
241{
242  rtems_time_of_day rtems_tod;
243
244  if (!RTC_Present)
245    return;
246
247  rtems_clock_get_tod( &rtems_tod );
248  RTC_Table[RTC_Minor].pDeviceFns->deviceSetTime(RTC_Minor, &rtems_tod);
249}
250
251/*PAGE
252 *
253 *  getRealTime
254 *
255 *  This routine reads the current time from the RTC.
256 *
257 *  Input parameters:  NONE
258 *
259 *  Output parameters:  NONE
260 *
261 *  Return values: NONE
262 */
263
264void getRealTime(
265  rtems_time_of_day *tod
266)
267{
268  if (!RTC_Present)
269    return;
270
271  RTC_Table[RTC_Minor].pDeviceFns->deviceGetTime(RTC_Minor, tod);
272}
273
274/*PAGE
275 *
276 *  setRealTime
277 *
278 *  This routine sets the RTC.
279 *
280 *  Input parameters:  NONE
281 *
282 *  Output parameters:  NONE
283 *
284 *  Return values: NONE
285 */
286int setRealTime(
287  const rtems_time_of_day *tod
288)
289{
290  if (!RTC_Present)
291    return -1;
292
293  if ( !_TOD_Validate(tod) )
294    return -1;
295
296  RTC_Table[RTC_Minor].pDeviceFns->deviceSetTime(RTC_Minor, tod);
297  return 0;
298}
299
300/*PAGE
301 *
302 *  checkRealTime
303 *
304 *  This routine reads the returns the variance betweent the real time and
305 *  rtems time.
306 *
307 *  Input parameters: NONE
308 *
309 *  Output parameters:  NONE
310 *
311 *  Return values:
312 *    int   The differance between the real time clock and rtems time.
313 */
314int checkRealTime(void)
315{
316  rtems_time_of_day rtems_tod;
317  rtems_time_of_day rtc_tod;
318  uint32_t   rtems_time;
319  uint32_t   rtc_time;
320
321  if (!RTC_Present)
322    return -1;
323
324  rtems_clock_get_tod( &rtems_tod );
325  RTC_Table[RTC_Minor].pDeviceFns->deviceGetTime(RTC_Minor, &rtc_tod);
326
327  rtems_time = _TOD_To_seconds( &rtems_tod );
328  rtc_time = _TOD_To_seconds( &rtc_tod );
329
330  return rtems_time - rtc_time;
331}
Note: See TracBrowser for help on using the repository browser.