Annotation of sys/dev/usb/udcf.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: udcf.c,v 1.38 2007/06/14 10:11:15 mbalmer Exp $ */
2:
3: /*
4: * Copyright (c) 2006 Marc Balmer <mbalmer@openbsd.org>
5: *
6: * Permission to use, copy, modify, and distribute this software for any
7: * purpose with or without fee is hereby granted, provided that the above
8: * copyright notice and this permission notice appear in all copies.
9: *
10: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17: */
18:
19: #include <sys/param.h>
20: #include <sys/systm.h>
21: #include <sys/kernel.h>
22: #include <sys/conf.h>
23: #include <sys/file.h>
24: #include <sys/select.h>
25: #include <sys/proc.h>
26: #include <sys/vnode.h>
27: #include <sys/device.h>
28: #include <sys/poll.h>
29: #include <sys/time.h>
30: #include <sys/sensors.h>
31:
32: #include <dev/usb/usb.h>
33: #include <dev/usb/usbdi.h>
34: #include <dev/usb/usbdi_util.h>
35: #include <dev/usb/usbdevs.h>
36:
37: #ifdef UDCF_DEBUG
38: #define DPRINTFN(n, x) do { if (udcfdebug > (n)) printf x; } while (0)
39: int udcfdebug = 0;
40: #else
41: #define DPRINTFN(n, x)
42: #endif
43: #define DPRINTF(x) DPRINTFN(0, x)
44:
45: #define UDCF_READ_REQ 0xc0
46: #define UDCF_READ_IDX 0x1f
47:
48: #define UDCF_CTRL_REQ 0x40
49: #define UDCF_CTRL_IDX 0x33
50: #define UDCF_CTRL_VAL 0x98
51:
52: #define DPERIOD1 ((long) 5 * 60) /* degrade OK -> WARN */
53: #define DPERIOD2 ((long) 15 * 60) /* degrade WARN -> CRIT */
54:
55: /* max. skew of received time diff vs. measured time diff in percent. */
56: #define MAX_SKEW 5
57:
58: #define CLOCK_DCF77 0
59: #define CLOCK_HBG 1
60:
61: static const char *clockname[2] = {
62: "DCF77",
63: "HBG" };
64:
65: struct udcf_softc {
66: struct device sc_dev; /* base device */
67: usbd_device_handle sc_udev; /* USB device */
68: usbd_interface_handle sc_iface; /* data interface */
69: u_char sc_dying; /* disconnecting */
70:
71: struct timeout sc_to;
72: struct usb_task sc_task;
73:
74: struct timeout sc_bv_to; /* bit-value detect */
75: struct timeout sc_db_to; /* debounce */
76: struct timeout sc_mg_to; /* minute-gap detect */
77: struct timeout sc_sl_to; /* signal-loss detect */
78: struct timeout sc_it_to; /* invalidate time */
79: struct timeout sc_ct_to; /* detect clock type */
80: struct usb_task sc_bv_task;
81: struct usb_task sc_mg_task;
82: struct usb_task sc_sl_task;
83: struct usb_task sc_it_task;
84: struct usb_task sc_ct_task;
85:
86: usb_device_request_t sc_req;
87:
88: int sc_clocktype; /* DCF77 or HBG */
89: int sc_sync; /* 1 during sync */
90: u_int64_t sc_mask; /* 64 bit mask */
91: u_int64_t sc_tbits; /* Time bits */
92: int sc_minute;
93: int sc_level;
94: time_t sc_last_mg;
95:
96: time_t sc_current; /* current time */
97: time_t sc_next; /* time to become valid next */
98: time_t sc_last;
99: int sc_nrecv; /* consecutive valid times */
100: struct timeval sc_last_tv; /* uptime of last valid time */
101: struct ksensor sc_sensor;
102: #ifdef UDCF_DEBUG
103: struct ksensor sc_skew; /* recv vs local skew */
104: #endif
105: struct ksensordev sc_sensordev;
106: };
107:
108: /*
109: * timeouts being used in hz:
110: * t_bv bit value detection (150ms)
111: * t_ct detect clocktype (250ms)
112: * t_sync sync (950ms)
113: * t_mg minute gap detection (1500ms)
114: * t_mgsync resync after a minute gap (450ms)
115: * t_sl detect signal loss (3sec)
116: * t_wait wait (5sec)
117: * t_warn degrade sensor status to warning (5min)
118: * t_crit degrade sensor status to critical (15min)
119: */
120: static int t_bv, t_ct, t_sync, t_mg, t_sl, t_mgsync, t_wait, t_warn, t_crit;
121:
122: void udcf_intr(void *);
123: void udcf_probe(void *);
124:
125: void udcf_bv_intr(void *);
126: void udcf_mg_intr(void *);
127: void udcf_sl_intr(void *);
128: void udcf_it_intr(void *);
129: void udcf_ct_intr(void *);
130: void udcf_bv_probe(void *);
131: void udcf_mg_probe(void *);
132: void udcf_sl_probe(void *);
133: void udcf_it_probe(void *);
134: void udcf_ct_probe(void *);
135:
136: int udcf_match(struct device *, void *, void *);
137: void udcf_attach(struct device *, struct device *, void *);
138: int udcf_detach(struct device *, int);
139: int udcf_activate(struct device *, enum devact);
140:
141: struct cfdriver udcf_cd = {
142: NULL, "udcf", DV_DULL
143: };
144:
145: const struct cfattach udcf_ca = {
146: sizeof(struct udcf_softc),
147: udcf_match,
148: udcf_attach,
149: udcf_detach,
150: udcf_activate,
151: };
152:
153: int
154: udcf_match(struct device *parent, void *match, void *aux)
155: {
156: struct usb_attach_arg *uaa = aux;
157:
158: if (uaa->iface != NULL)
159: return UMATCH_NONE;
160:
161: return uaa->vendor == USB_VENDOR_GUDE &&
162: uaa->product == USB_PRODUCT_GUDE_DCF ?
163: UMATCH_VENDOR_PRODUCT : UMATCH_NONE;
164: }
165:
166: void
167: udcf_attach(struct device *parent, struct device *self, void *aux)
168: {
169: struct udcf_softc *sc = (struct udcf_softc *)self;
170: struct usb_attach_arg *uaa = aux;
171: usbd_device_handle dev = uaa->device;
172: usbd_interface_handle iface;
173: struct timeval t;
174: char *devinfop;
175: usb_interface_descriptor_t *id;
176: usbd_status err;
177: usb_device_request_t req;
178: uWord result;
179: int actlen;
180:
181: if ((err = usbd_set_config_index(dev, 0, 1))) {
182: DPRINTF(("\n%s: failed to set configuration, err=%s\n",
183: sc->sc_dev.dv_xname, usbd_errstr(err)));
184: goto fishy;
185: }
186:
187: if ((err = usbd_device2interface_handle(dev, 0, &iface))) {
188: DPRINTF(("\n%s: failed to get interface, err=%s\n",
189: sc->sc_dev.dv_xname, usbd_errstr(err)));
190: goto fishy;
191: }
192:
193: devinfop = usbd_devinfo_alloc(dev, 0);
194: printf("\n%s: %s\n", sc->sc_dev.dv_xname, devinfop);
195: usbd_devinfo_free(devinfop);
196:
197: id = usbd_get_interface_descriptor(iface);
198:
199: sc->sc_udev = dev;
200: sc->sc_iface = iface;
201:
202: sc->sc_clocktype = -1;
203: sc->sc_level = 0;
204: sc->sc_minute = 0;
205: sc->sc_last_mg = 0L;
206:
207: sc->sc_sync = 1;
208:
209: sc->sc_current = 0L;
210: sc->sc_next = 0L;
211: sc->sc_nrecv = 0;
212: sc->sc_last = 0L;
213: sc->sc_last_tv.tv_sec = 0L;
214:
215: strlcpy(sc->sc_sensordev.xname, sc->sc_dev.dv_xname,
216: sizeof(sc->sc_sensordev.xname));
217:
218: sc->sc_sensor.type = SENSOR_TIMEDELTA;
219: sc->sc_sensor.status = SENSOR_S_UNKNOWN;
220: sc->sc_sensor.value = 0LL;
221: sc->sc_sensor.flags = 0;
222: strlcpy(sc->sc_sensor.desc, "Unknown", sizeof(sc->sc_sensor.desc));
223: sensor_attach(&sc->sc_sensordev, &sc->sc_sensor);
224:
225: #ifdef UDCF_DEBUG
226: sc->sc_skew.type = SENSOR_TIMEDELTA;
227: sc->sc_skew.status = SENSOR_S_UNKNOWN;
228: sc->sc_skew.value = 0LL;
229: sc->sc_skew.flags = 0;
230: strlcpy(sc->sc_skew.desc, "local clock skew",
231: sizeof(sc->sc_skew.desc));
232: sensor_attach(&sc->sc_sensordev, &sc->sc_skew);
233: #endif
234:
235: sensordev_install(&sc->sc_sensordev);
236:
237: /* Prepare the USB request to probe the value */
238: sc->sc_req.bmRequestType = UDCF_READ_REQ;
239: sc->sc_req.bRequest = 1;
240: USETW(sc->sc_req.wValue, 0);
241: USETW(sc->sc_req.wIndex, UDCF_READ_IDX);
242: USETW(sc->sc_req.wLength, 1);
243:
244: req.bmRequestType = UDCF_CTRL_REQ;
245: req.bRequest = 0;
246: USETW(req.wValue, 0);
247: USETW(req.wIndex, 0);
248: USETW(req.wLength, 0);
249: if ((err = usbd_do_request_flags(sc->sc_udev, &req, &result,
250: USBD_SHORT_XFER_OK, &actlen, USBD_DEFAULT_TIMEOUT))) {
251: DPRINTF(("failed to turn on power for receiver\n"));
252: goto fishy;
253: }
254:
255: req.bmRequestType = UDCF_CTRL_REQ;
256: req.bRequest = 0;
257: USETW(req.wValue, UDCF_CTRL_VAL);
258: USETW(req.wIndex, UDCF_CTRL_IDX);
259: USETW(req.wLength, 0);
260: if ((err = usbd_do_request_flags(sc->sc_udev, &req, &result,
261: USBD_SHORT_XFER_OK, &actlen, USBD_DEFAULT_TIMEOUT))) {
262: DPRINTF(("failed to turn on receiver\n"));
263: goto fishy;
264: }
265:
266: usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev,
267: &sc->sc_dev);
268:
269: usb_init_task(&sc->sc_task, udcf_probe, sc);
270: usb_init_task(&sc->sc_bv_task, udcf_bv_probe, sc);
271: usb_init_task(&sc->sc_mg_task, udcf_mg_probe, sc);
272: usb_init_task(&sc->sc_sl_task, udcf_sl_probe, sc);
273: usb_init_task(&sc->sc_it_task, udcf_it_probe, sc);
274: usb_init_task(&sc->sc_ct_task, udcf_ct_probe, sc);
275:
276: timeout_set(&sc->sc_to, udcf_intr, sc);
277: timeout_set(&sc->sc_bv_to, udcf_bv_intr, sc);
278: timeout_set(&sc->sc_mg_to, udcf_mg_intr, sc);
279: timeout_set(&sc->sc_sl_to, udcf_sl_intr, sc);
280: timeout_set(&sc->sc_it_to, udcf_it_intr, sc);
281: timeout_set(&sc->sc_ct_to, udcf_ct_intr, sc);
282:
283: /* convert timevals to hz */
284: t.tv_sec = 0L;
285: t.tv_usec = 150000L;
286: t_bv = tvtohz(&t);
287:
288: t.tv_usec = 450000L;
289: t_mgsync = tvtohz(&t);
290:
291: t.tv_usec = 950000L;
292: t_sync = tvtohz(&t);
293:
294: t.tv_sec = 1L;
295: t.tv_usec = 500000L;
296: t_mg = tvtohz(&t);
297:
298: t.tv_sec = 3L;
299: t.tv_usec = 0L;
300: t_sl = tvtohz(&t);
301:
302: t.tv_sec = 5L;
303: t_wait = tvtohz(&t);
304:
305: t.tv_sec = DPERIOD1;
306: t_warn = tvtohz(&t);
307:
308: t.tv_sec = DPERIOD2;
309: t_crit = tvtohz(&t);
310:
311: t.tv_sec = 0L;
312: t.tv_usec = 250000L;
313: t_ct = tvtohz(&t);
314:
315: /* Give the receiver some slack to stabilize */
316: timeout_add(&sc->sc_to, t_wait);
317:
318: /* Detect signal loss */
319: timeout_add(&sc->sc_sl_to, t_wait + t_sl);
320:
321: DPRINTF(("synchronizing\n"));
322: return;
323:
324: fishy:
325: DPRINTF(("udcf_attach failed\n"));
326: sc->sc_dying = 1;
327: }
328:
329: int
330: udcf_detach(struct device *self, int flags)
331: {
332: struct udcf_softc *sc = (struct udcf_softc *)self;
333:
334: sc->sc_dying = 1;
335:
336: timeout_del(&sc->sc_to);
337: timeout_del(&sc->sc_bv_to);
338: timeout_del(&sc->sc_mg_to);
339: timeout_del(&sc->sc_sl_to);
340: timeout_del(&sc->sc_it_to);
341: timeout_del(&sc->sc_ct_to);
342:
343: /* Unregister the clock with the kernel */
344: sensordev_deinstall(&sc->sc_sensordev);
345: usb_rem_task(sc->sc_udev, &sc->sc_task);
346: usb_rem_task(sc->sc_udev, &sc->sc_bv_task);
347: usb_rem_task(sc->sc_udev, &sc->sc_mg_task);
348: usb_rem_task(sc->sc_udev, &sc->sc_sl_task);
349: usb_rem_task(sc->sc_udev, &sc->sc_it_task);
350: usb_rem_task(sc->sc_udev, &sc->sc_ct_task);
351:
352: usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
353: &sc->sc_dev);
354: return 0;
355: }
356:
357: /* udcf_intr runs in an interrupt context */
358: void
359: udcf_intr(void *xsc)
360: {
361: struct udcf_softc *sc = xsc;
362: usb_add_task(sc->sc_udev, &sc->sc_task);
363: }
364:
365: /* bit value detection */
366: void
367: udcf_bv_intr(void *xsc)
368: {
369: struct udcf_softc *sc = xsc;
370: usb_add_task(sc->sc_udev, &sc->sc_bv_task);
371: }
372:
373: /* minute gap detection */
374: void
375: udcf_mg_intr(void *xsc)
376: {
377: struct udcf_softc *sc = xsc;
378: usb_add_task(sc->sc_udev, &sc->sc_mg_task);
379: }
380:
381: /* signal loss detection */
382: void
383: udcf_sl_intr(void *xsc)
384: {
385: struct udcf_softc *sc = xsc;
386: usb_add_task(sc->sc_udev, &sc->sc_sl_task);
387: }
388:
389: /* degrade the sensor */
390: void
391: udcf_it_intr(void *xsc)
392: {
393: struct udcf_softc *sc = xsc;
394: usb_add_task(sc->sc_udev, &sc->sc_it_task);
395: }
396:
397: /* detect the clock type (DCF77 or HBG) */
398: void
399: udcf_ct_intr(void *xsc)
400: {
401: struct udcf_softc *sc = xsc;
402: usb_add_task(sc->sc_udev, &sc->sc_ct_task);
403: }
404:
405: /*
406: * udcf_probe runs in a process context. If bit 0 is set, the transmitter
407: * emits at full power. During the low-power emission we decode a zero bit.
408: */
409: void
410: udcf_probe(void *xsc)
411: {
412: struct udcf_softc *sc = xsc;
413: struct timespec now;
414: unsigned char data;
415: int actlen;
416:
417: if (sc->sc_dying)
418: return;
419:
420: if (usbd_do_request_flags(sc->sc_udev, &sc->sc_req, &data,
421: USBD_SHORT_XFER_OK, &actlen, USBD_DEFAULT_TIMEOUT))
422: /* This happens if we pull the receiver */
423: return;
424:
425: if (data & 0x01) {
426: sc->sc_level = 1;
427: timeout_add(&sc->sc_to, 1);
428: return;
429: }
430:
431: if (sc->sc_level == 0)
432: return;
433:
434: /* Begin of a second */
435: sc->sc_level = 0;
436: if (sc->sc_minute == 1) {
437: if (sc->sc_sync) {
438: DPRINTF(("start collecting bits\n"));
439: sc->sc_sync = 0;
440: if (sc->sc_sensor.status == SENSOR_S_UNKNOWN)
441: sc->sc_clocktype = -1;
442: } else {
443: /* provide the timedelta */
444: microtime(&sc->sc_sensor.tv);
445: nanotime(&now);
446: sc->sc_current = sc->sc_next;
447: sc->sc_sensor.value = (int64_t)(now.tv_sec -
448: sc->sc_current) * 1000000000LL + now.tv_nsec;
449:
450: /* set the clocktype and make sensor valid */
451: if (sc->sc_sensor.status == SENSOR_S_UNKNOWN) {
452: strlcpy(sc->sc_sensor.desc, sc->sc_clocktype ?
453: clockname[CLOCK_HBG] :
454: clockname[CLOCK_DCF77],
455: sizeof(sc->sc_sensor.desc));
456: }
457: sc->sc_sensor.status = SENSOR_S_OK;
458:
459: /*
460: * if no valid time information is received
461: * during the next 5 minutes, the sensor state
462: * will be degraded to SENSOR_S_WARN
463: */
464: timeout_add(&sc->sc_it_to, t_warn);
465: }
466: sc->sc_minute = 0;
467: }
468:
469: timeout_add(&sc->sc_to, t_sync); /* resync in 950 ms */
470:
471: /* No clock and bit detection during sync */
472: if (!sc->sc_sync) {
473: /* detect bit value */
474: timeout_add(&sc->sc_bv_to, t_bv);
475:
476: /* detect clocktype */
477: if (sc->sc_clocktype == -1)
478: timeout_add(&sc->sc_ct_to, t_ct);
479: }
480: timeout_add(&sc->sc_mg_to, t_mg); /* detect minute gap */
481: timeout_add(&sc->sc_sl_to, t_sl); /* detect signal loss */
482: }
483:
484: /* detect the bit value */
485: void
486: udcf_bv_probe(void *xsc)
487: {
488: struct udcf_softc *sc = xsc;
489: int actlen;
490: unsigned char data;
491:
492: if (sc->sc_dying)
493: return;
494:
495: if (usbd_do_request_flags(sc->sc_udev, &sc->sc_req, &data,
496: USBD_SHORT_XFER_OK, &actlen, USBD_DEFAULT_TIMEOUT)) {
497: /* This happens if we pull the receiver */
498: DPRINTF(("bit detection failed\n"));
499: return;
500: }
501:
502: DPRINTFN(1, (data & 0x01 ? "0" : "1"));
503: if (!(data & 0x01))
504: sc->sc_tbits |= sc->sc_mask;
505: sc->sc_mask <<= 1;
506: }
507:
508: /* detect the minute gap */
509: void
510: udcf_mg_probe(void *xsc)
511: {
512: struct udcf_softc *sc = xsc;
513: struct clock_ymdhms ymdhm;
514: struct timeval monotime;
515: int tdiff_recv, tdiff_local;
516: int skew;
517: int minute_bits, hour_bits, day_bits;
518: int month_bits, year_bits, wday;
519: int p1, p2, p3;
520: int p1_bit, p2_bit, p3_bit;
521: int r_bit, a1_bit, a2_bit, z1_bit, z2_bit;
522: int s_bit, m_bit;
523: u_int32_t parity = 0x6996;
524:
525: if (sc->sc_sync) {
526: sc->sc_minute = 1;
527: goto cleanbits;
528: }
529:
530: if (time_second - sc->sc_last_mg < 57) {
531: DPRINTF(("\nunexpected gap, resync\n"));
532: sc->sc_sync = sc->sc_minute = 1;
533: goto cleanbits;
534: }
535:
536: /* Extract bits w/o parity */
537: m_bit = sc->sc_tbits & 1;
538: r_bit = sc->sc_tbits >> 15 & 1;
539: a1_bit = sc->sc_tbits >> 16 & 1;
540: z1_bit = sc->sc_tbits >> 17 & 1;
541: z2_bit = sc->sc_tbits >> 18 & 1;
542: a2_bit = sc->sc_tbits >> 19 & 1;
543: s_bit = sc->sc_tbits >> 20 & 1;
544: p1_bit = sc->sc_tbits >> 28 & 1;
545: p2_bit = sc->sc_tbits >> 35 & 1;
546: p3_bit = sc->sc_tbits >> 58 & 1;
547:
548: minute_bits = sc->sc_tbits >> 21 & 0x7f;
549: hour_bits = sc->sc_tbits >> 29 & 0x3f;
550: day_bits = sc->sc_tbits >> 36 & 0x3f;
551: wday = (sc->sc_tbits >> 42) & 0x07;
552: month_bits = sc->sc_tbits >> 45 & 0x1f;
553: year_bits = sc->sc_tbits >> 50 & 0xff;
554:
555: /* Validate time information */
556: p1 = (parity >> (minute_bits & 0x0f) & 1) ^
557: (parity >> (minute_bits >> 4) & 1);
558:
559: p2 = (parity >> (hour_bits & 0x0f) & 1) ^
560: (parity >> (hour_bits >> 4) & 1);
561:
562: p3 = (parity >> (day_bits & 0x0f) & 1) ^
563: (parity >> (day_bits >> 4) & 1) ^
564: ((parity >> wday) & 1) ^ (parity >> (month_bits & 0x0f) & 1) ^
565: (parity >> (month_bits >> 4) & 1) ^
566: (parity >> (year_bits & 0x0f) & 1) ^
567: (parity >> (year_bits >> 4) & 1);
568:
569: if (m_bit == 0 && s_bit == 1 && p1 == p1_bit && p2 == p2_bit &&
570: p3 == p3_bit && (z1_bit ^ z2_bit)) {
571:
572: /* Decode time */
573: if ((ymdhm.dt_year = 2000 + FROMBCD(year_bits)) > 2037) {
574: DPRINTF(("year out of range, resync\n"));
575: sc->sc_sync = 1;
576: goto cleanbits;
577: }
578: ymdhm.dt_min = FROMBCD(minute_bits);
579: ymdhm.dt_hour = FROMBCD(hour_bits);
580: ymdhm.dt_day = FROMBCD(day_bits);
581: ymdhm.dt_mon = FROMBCD(month_bits);
582: ymdhm.dt_sec = 0;
583:
584: sc->sc_next = clock_ymdhms_to_secs(&ymdhm);
585: getmicrouptime(&monotime);
586:
587: /* convert to coordinated universal time */
588: sc->sc_next -= z1_bit ? 7200 : 3600;
589:
590: DPRINTF(("\n%02d.%02d.%04d %02d:%02d:00 %s",
591: ymdhm.dt_day, ymdhm.dt_mon, ymdhm.dt_year,
592: ymdhm.dt_hour, ymdhm.dt_min, z1_bit ? "CEST" : "CET"));
593: DPRINTF((r_bit ? ", call bit" : ""));
594: DPRINTF((a1_bit ? ", dst chg ann." : ""));
595: DPRINTF((a2_bit ? ", leap sec ann." : ""));
596: DPRINTF(("\n"));
597:
598: if (sc->sc_last) {
599: tdiff_recv = sc->sc_next - sc->sc_last;
600: tdiff_local = monotime.tv_sec - sc->sc_last_tv.tv_sec;
601: skew = abs(tdiff_local - tdiff_recv);
602: #ifdef UDCF_DEBUG
603: if (sc->sc_skew.status == SENSOR_S_UNKNOWN)
604: sc->sc_skew.status = SENSOR_S_CRIT;
605: sc->sc_skew.value = skew * 1000000000LL;
606: getmicrotime(&sc->sc_skew.tv);
607: #endif
608: DPRINTF(("local = %d, recv = %d, skew = %d\n",
609: tdiff_local, tdiff_recv, skew));
610:
611: if (skew && skew * 100LL / tdiff_local > MAX_SKEW) {
612: DPRINTF(("skew out of tolerated range\n"));
613: goto cleanbits;
614: } else {
615: if (sc->sc_nrecv < 2) {
616: sc->sc_nrecv++;
617: DPRINTF(("got frame %d\n",
618: sc->sc_nrecv));
619: } else {
620: DPRINTF(("data is valid\n"));
621: sc->sc_minute = 1;
622: }
623: }
624: } else {
625: DPRINTF(("received the first frame\n"));
626: sc->sc_nrecv = 1;
627: }
628:
629: /* record the time received and when it was received */
630: sc->sc_last = sc->sc_next;
631: sc->sc_last_tv.tv_sec = monotime.tv_sec;
632: } else {
633: DPRINTF(("\nparity error, resync\n"));
634: sc->sc_sync = sc->sc_minute = 1;
635: }
636:
637: cleanbits:
638: timeout_add(&sc->sc_to, t_mgsync); /* re-sync in 450 ms */
639: sc->sc_last_mg = time_second;
640: sc->sc_tbits = 0LL;
641: sc->sc_mask = 1LL;
642: }
643:
644: /* detect signal loss */
645: void
646: udcf_sl_probe(void *xsc)
647: {
648: struct udcf_softc *sc = xsc;
649:
650: if (sc->sc_dying)
651: return;
652:
653: DPRINTF(("no signal\n"));
654: sc->sc_sync = 1;
655: timeout_add(&sc->sc_to, t_wait);
656: timeout_add(&sc->sc_sl_to, t_wait + t_sl);
657: }
658:
659: /* invalidate timedelta */
660: void
661: udcf_it_probe(void *xsc)
662: {
663: struct udcf_softc *sc = xsc;
664:
665: if (sc->sc_dying)
666: return;
667:
668: DPRINTF(("\ndegrading sensor state\n"));
669:
670: if (sc->sc_sensor.status == SENSOR_S_OK) {
671: sc->sc_sensor.status = SENSOR_S_WARN;
672: /*
673: * further degrade in 15 minutes if we dont receive any new
674: * time information
675: */
676: timeout_add(&sc->sc_it_to, t_crit);
677: } else {
678: sc->sc_sensor.status = SENSOR_S_CRIT;
679: sc->sc_nrecv = 0;
680: }
681: }
682:
683: /* detect clock type */
684: void
685: udcf_ct_probe(void *xsc)
686: {
687: struct udcf_softc *sc = xsc;
688: int actlen;
689: unsigned char data;
690:
691: if (sc->sc_dying)
692: return;
693:
694: if (usbd_do_request_flags(sc->sc_udev, &sc->sc_req, &data,
695: USBD_SHORT_XFER_OK, &actlen, USBD_DEFAULT_TIMEOUT)) {
696: /* This happens if we pull the receiver */
697: DPRINTF(("clocktype detection failed\n"));
698: return;
699: }
700:
701: sc->sc_clocktype = data & 0x01 ? 0 : 1;
702: DPRINTF(("\nclocktype is %s\n", sc->sc_clocktype ?
703: clockname[CLOCK_HBG] : clockname[CLOCK_DCF77]));
704: }
705:
706: int
707: udcf_activate(struct device *self, enum devact act)
708: {
709: struct udcf_softc *sc = (struct udcf_softc *)self;
710:
711: switch (act) {
712: case DVACT_ACTIVATE:
713: break;
714: case DVACT_DEACTIVATE:
715: sc->sc_dying = 1;
716: break;
717: }
718: return 0;
719: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to udcf.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / usb