1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
|
/**************************************************************************
* arch/arm/src/c5471/c5471_watchdog.c
*
* Copyright (C) 2007, 2009, 2012-2014 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <gnutt@nuttx.org>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name NuttX nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
**************************************************************************/
/**************************************************************************
* Included Files
**************************************************************************/
#include <nuttx/config.h>
#include <sys/types.h>
#include <stdint.h>
#include <stdbool.h>
#include <stdio.h>
#include <debug.h>
#include <errno.h>
#include <nuttx/fs/fs.h>
#include <nuttx/irq.h>
#include <nuttx/watchdog.h>
#include <arch/watchdog.h>
#include "chip.h"
#include "up_arch.h"
/**************************************************************************
* Definitions
**************************************************************************/
#undef CONFIG_SOFTWARE_TEST
#undef CONFIG_SOFTWARE_REBOOT
#undef CONFIG_WATCHDOG_STRICT
#define MAX_WDT_USEC 353200
#define MAX_PRESCALER 256
#define C5471_TIMER_STOP 0
#define C5471_TIMER_PRESCALER 0x07 /* Bits 0-2: Prescale value */
#define C5471_TIMER_STARTBIT (1 << 3) /* Bit 3: Start timer bit */
#define C5471_TIMER_AUTORELOAD (1 << 4) /* Bit 4: Auto-reload timer */
#define C5471_TIMER_LOADTIM (0xffff << 5) /* Bits 20-5: Load timer value */
#define C5471_TIMER_MODE (1 << 21) /* Bit 21: Timer mode */
#define C5471_DISABLE_VALUE1 (0xf5 << 22) /* Bits 29-22: WD disable */
#define C5471_DISABLE_VALUE2 (0xa0 << 22)
#define CLOCK_KHZ 47500
#define CLOCK_MHZx2 95
/* Macros to manage access to to watchdog timer macros */
#define c5471_wdt_cntl (*(volatile uint32_t*)C5471_TIMER0_CTRL)
#define c5471_wdt_count (*(volatile uint32_t*)C5471_TIMER0_CNT)
/**************************************************************************
* Private Types
**************************************************************************/
/**************************************************************************
* Private Function Prototypes
**************************************************************************/
/* Local implementation of timer interface */
static inline unsigned int wdt_prescaletoptv(unsigned int prescale);
static int wdt_setusec(uint32_t usec);
static int wdt_interrupt(int irq, void *context);
static int wdt_open(struct file *filep);
static int wdt_close(struct file *filep);
static ssize_t wdt_read(struct file *filep, char *buffer, size_t buflen);
static ssize_t wdt_write(struct file *filep, const char *buffer, size_t buflen);
static int wdt_ioctl(FAR struct file *filep, int cmd, unsigned long arg);
/**************************************************************************
* Private Data
**************************************************************************/
static bool g_wdtopen;
static const struct file_operations g_wdtops =
{
.open = wdt_open,
.close = wdt_close,
.read = wdt_read,
.write = wdt_write,
.ioctl = wdt_ioctl,
};
/**************************************************************************
* Private Functions
**************************************************************************/
/**************************************************************************
* Name: wdt_prescaletoptv
**************************************************************************/
static inline unsigned int wdt_prescaletoptv(unsigned int prescale)
{
unsigned int ptv = 0;
if (prescale > 255)
{
ptv = 7;
}
else
{
unsigned int value = prescale >> 1;
/* 0: 0-2
* 1: 3-4
* 2: 5-8
* 3: 9-16
* 4: 17-32
* 5: 33-64
* 6: 65-128
* 7: 129-
*/
while (value > 1)
{
value >>= 1;
ptv++;
}
}
dbg("prescale=%d -> ptv=%d\n", prescale, ptv);
return ptv;
}
/**************************************************************************
* Name: wdt_setusec
**************************************************************************/
static int wdt_setusec(uint32_t usec)
{
/* prescaler: clock / prescaler = #clock ticks per counter in ptv
* divisor: #counts until the interrupt comes.
*/
uint32_t prescaler = MAX_PRESCALER;
uint32_t divisor = 1;
uint32_t mode;
dbg("usec=%d\n", usec);
/* Calculate a value of prescaler and divisor that will be able
* to count to the usec. It may not be exact or the best
* possible set, but it's a quick and simple algorithm.
*
* divisor max = 0x10000
* prescaler max = MAX_PRESCALER
*/
do
{
divisor = (CLOCK_MHZx2 * usec) / (prescaler * 2);
dbg("divisor=0x%x prescaler=0x%x\n", divisor, prescaler);
if (divisor >= 0x10000)
{
if (prescaler == MAX_PRESCALER)
{
/* This is the max possible ~2.5 seconds. */
dbg("prescaler=0x%x too big!\n", prescaler);
return ERROR;
}
prescaler <<= 1;
if (prescaler > MAX_PRESCALER)
{
prescaler = MAX_PRESCALER;
}
}
}
while (divisor >= 0x10000);
dbg("prescaler=0x%x divisor=0x%x\n", prescaler, divisor);
mode = wdt_prescaletoptv(prescaler);
mode &= ~C5471_TIMER_AUTORELOAD; /* One shot mode. */
mode |= divisor << 5;
dbg("mode=0x%x\n", mode);
c5471_wdt_cntl = mode;
/* Now start the watchdog */
c5471_wdt_cntl |= C5471_TIMER_STARTBIT;
dbg("cntl_timer=0x%x\n", c5471_wdt_cntl);
return 0;
}
/**************************************************************************
* Private Functions
**************************************************************************/
/**************************************************************************
* Name: wdt_interrupt
**************************************************************************/
static int wdt_interrupt(int irq, void *context)
{
dbg("expired\n");
#if defined(CONFIG_SOFTWARE_REBOOT)
# if defined(CONFIG_SOFTWARE_TEST)
dbg(" Test only\n");
# else
dbg(" Re-booting\n");
# warning "Add logic to reset CPU here"
# endif
#else
dbg(" No reboot\n");
#endif
return OK;
}
/**************************************************************************
* Name: wdt_read
**************************************************************************/
static ssize_t wdt_read(struct file *filep, char *buffer, size_t buflen)
{
/* We are going to return "NNNNNNNN NNNNNNNN." The followig logic will
* not work if the user provides a buffer smaller than 18 bytes.
*/
dbg("buflen=%d\n", buflen);
if (buflen >= 18)
{
sprintf(buffer, "%08x %08x\n", c5471_wdt_cntl, c5471_wdt_count);
return 18;
}
return 0;
}
/**************************************************************************
* Name: wdt_write
**************************************************************************/
static ssize_t wdt_write(struct file *filep, const char *buffer, size_t buflen)
{
dbg("buflen=%d\n", buflen);
if (buflen)
{
/* Reset the timer to the maximum delay */
wdt_setusec(MAX_WDT_USEC);
return 1;
}
return 0;
}
/**************************************************************************
* Name: wdt_ioctl
**************************************************************************/
static int wdt_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
{
dbg("ioctl Call: cmd=0x%x arg=0x%x", cmd, arg);
/* Process the IOCTL command (see arch/watchdog.h) */
switch(cmd)
{
case WDIOC_KEEPALIVE:
wdt_setusec(MAX_WDT_USEC);
break;
default:
return -ENOTTY;
}
return OK;
}
/**************************************************************************
* Name: wdt_open
**************************************************************************/
static int wdt_open(struct file *filep)
{
dbg("");
if (g_wdtopen)
{
return -EBUSY;
}
/* This will automatically load the timer with its max
* count and start it running.
*/
c5471_wdt_cntl = C5471_DISABLE_VALUE1;
c5471_wdt_cntl = C5471_DISABLE_VALUE2;
g_wdtopen = true;
return OK;
}
/**************************************************************************
* Name: wdt_close
**************************************************************************/
static int wdt_close(struct file *filep)
{
dbg("");
/* The task controlling the watchdog has terminated. Take the timer
* the
* watchdog in interrupt mode -- we are going to reset unless the
* reopened again soon.
*/
#ifndef CONFIG_WATCHDOG_STRICT
c5471_wdt_cntl = C5471_TIMER_MODE;
#endif
g_wdtopen = false;
return 0;
}
/**************************************************************************
* Public Functions
**************************************************************************/
/**************************************************************************
* Name: up_wdtinit
**************************************************************************/
int up_wdtinit(void)
{
int ret;
dbg("C547x Watchdog Driver\n");
/* Register as /dev/wdt */
ret = register_driver("/dev/wdt", &g_wdtops, 0666, NULL);
if (ret)
{
return ERROR;
}
/* Register for an interrupt level callback through wdt_interrupt */
dbg("Attach to IRQ=%d\n", C5471_IRQ_WATCHDOG);
/* Make sure that the timer is stopped */
c5471_wdt_cntl = C5471_TIMER_STOP;
/* Request the interrupt. */
ret = irq_attach(C5471_IRQ_WATCHDOG, wdt_interrupt);
if (ret)
{
unregister_driver("/dev/wdt");
return ERROR;
}
return OK;
}
|