/*      $OpenBSD: udcf.c,v 1.66 2024/05/23 03:21:09 jsg Exp $ */

/*
 * Copyright (c) 2006, 2007, 2008 Marc Balmer <mbalmer@openbsd.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/device.h>
#include <sys/time.h>
#include <sys/sensors.h>
#include <sys/timeout.h>

#include <dev/usb/usb.h>
#include <dev/usb/usbdi.h>
#include <dev/usb/usbdevs.h>

#ifdef UDCF_DEBUG
#define DPRINTFN(n, x)  do { if (udcfdebug > (n)) printf x; } while (0)
int udcfdebug = 0;
#else
#define DPRINTFN(n, x)
#endif
#define DPRINTF(x)      DPRINTFN(0, x)

#define UDCF_READ_IDX   0x1f

#define UDCF_CTRL_IDX   0x33
#define UDCF_CTRL_VAL   0x98

#define FT232R_RESET    0x00    /* reset USB request */
#define FT232R_STATUS   0x05    /* get modem status USB request */
#define FT232R_RI       0x40    /* ring indicator */

/* max. skew of received time diff vs. measured time diff in percent. */
#define MAX_SKEW        5

#define CLOCK_DCF77     "DCF77"

struct udcf_softc {
        struct device           sc_dev;         /* base device */
        struct usbd_device      *sc_udev;       /* USB device */
        struct usbd_interface   *sc_iface;      /* data interface */

        struct timeout          sc_to;
        struct usb_task         sc_task;

        struct timeout          sc_bv_to;       /* bit-value detect */
        struct timeout          sc_db_to;       /* debounce */
        struct timeout          sc_mg_to;       /* minute-gap detect */
        struct timeout          sc_sl_to;       /* signal-loss detect */
        struct timeout          sc_it_to;       /* invalidate time */
        struct usb_task         sc_bv_task;
        struct usb_task         sc_mg_task;
        struct usb_task         sc_sl_task;

        usb_device_request_t    sc_req;

        int                     sc_sync;        /* 1 during sync */
        u_int64_t               sc_mask;        /* 64 bit mask */
        u_int64_t               sc_tbits;       /* Time bits */
        int                     sc_minute;
        int                     sc_level;
        time_t                  sc_last_mg;
        int                     (*sc_signal)(struct udcf_softc *);

        time_t                  sc_current;     /* current time */
        time_t                  sc_next;        /* time to become valid next */
        time_t                  sc_last;
        int                     sc_nrecv;       /* consecutive valid times */
        struct timeval          sc_last_tv;     /* uptime of last valid time */
        struct ksensor          sc_sensor;
#ifdef UDCF_DEBUG
        struct ksensor          sc_skew;        /* recv vs local skew */
#endif
        struct ksensordev       sc_sensordev;
};

/* timeouts in milliseconds: */
#define T_BV            150     /* bit value detection (150ms) */
#define T_SYNC          950     /* sync (950ms) */
#define T_MG            1500    /* minute gap detection (1500ms) */
#define T_MGSYNC        450     /* resync after a minute gap (450ms) */
#define T_SL            3000    /* detect signal loss (3sec) */
#define T_WAIT          5000    /* wait (5sec) */
#define T_WARN          300000  /* degrade sensor status to warning (5min) */
#define T_CRIT          900000  /* degrade sensor status to critical (15min) */

void    udcf_intr(void *);
void    udcf_probe(void *);

void    udcf_bv_intr(void *);
void    udcf_mg_intr(void *);
void    udcf_sl_intr(void *);
void    udcf_it_intr(void *);
void    udcf_bv_probe(void *);
void    udcf_mg_probe(void *);
void    udcf_sl_probe(void *);

int udcf_match(struct device *, void *, void *);
void udcf_attach(struct device *, struct device *, void *);
int udcf_detach(struct device *, int);

int udcf_nc_signal(struct udcf_softc *);
int udcf_nc_init_hw(struct udcf_softc *);
int udcf_ft232r_signal(struct udcf_softc *);
int udcf_ft232r_init_hw(struct udcf_softc *);

struct cfdriver udcf_cd = {
        NULL, "udcf", DV_DULL
};

const struct cfattach udcf_ca = {
        sizeof(struct udcf_softc), udcf_match, udcf_attach, udcf_detach,
};

static const struct usb_devno udcf_devs[] = {
        { USB_VENDOR_GUDE, USB_PRODUCT_GUDE_DCF },
        { USB_VENDOR_FTDI, USB_PRODUCT_FTDI_DCF }
};

int
udcf_match(struct device *parent, void *match, void *aux)
{
        struct usb_attach_arg           *uaa = aux;

        if (uaa->iface == NULL)
                return UMATCH_NONE;

        return (usb_lookup(udcf_devs, uaa->vendor, uaa->product) != NULL ?
            UMATCH_VENDOR_PRODUCT : UMATCH_NONE);
}

void
udcf_attach(struct device *parent, struct device *self, void *aux)
{
        struct udcf_softc               *sc = (struct udcf_softc *)self;
        struct usb_attach_arg           *uaa = aux;
        struct usbd_device              *dev = uaa->device;
        struct usbd_interface           *iface;
        usbd_status                      err;

        switch (uaa->product) {
        case USB_PRODUCT_GUDE_DCF:
                sc->sc_signal = udcf_nc_signal;
                strlcpy(sc->sc_sensor.desc, "DCF77",
                    sizeof(sc->sc_sensor.desc));
                break;
        case USB_PRODUCT_FTDI_DCF:
                sc->sc_signal = udcf_ft232r_signal;
                strlcpy(sc->sc_sensor.desc, "DCF77",
                    sizeof(sc->sc_sensor.desc));
                break;
        }

        usb_init_task(&sc->sc_task, udcf_probe, sc, USB_TASK_TYPE_GENERIC);
        usb_init_task(&sc->sc_bv_task, udcf_bv_probe, sc, USB_TASK_TYPE_GENERIC);
        usb_init_task(&sc->sc_mg_task, udcf_mg_probe, sc, USB_TASK_TYPE_GENERIC);
        usb_init_task(&sc->sc_sl_task, udcf_sl_probe, sc, USB_TASK_TYPE_GENERIC);

        timeout_set(&sc->sc_to, udcf_intr, sc);
        timeout_set(&sc->sc_bv_to, udcf_bv_intr, sc);
        timeout_set(&sc->sc_mg_to, udcf_mg_intr, sc);
        timeout_set(&sc->sc_sl_to, udcf_sl_intr, sc);
        timeout_set(&sc->sc_it_to, udcf_it_intr, sc);

        strlcpy(sc->sc_sensordev.xname, sc->sc_dev.dv_xname,
            sizeof(sc->sc_sensordev.xname));

        sc->sc_sensor.type = SENSOR_TIMEDELTA;
        sc->sc_sensor.status = SENSOR_S_UNKNOWN;
        sensor_attach(&sc->sc_sensordev, &sc->sc_sensor);

#ifdef UDCF_DEBUG
        sc->sc_skew.type = SENSOR_TIMEDELTA;
        sc->sc_skew.status = SENSOR_S_UNKNOWN;
        strlcpy(sc->sc_skew.desc, "local clock skew",
            sizeof(sc->sc_skew.desc));
        sensor_attach(&sc->sc_sensordev, &sc->sc_skew);
#endif
        sensordev_install(&sc->sc_sensordev);

        sc->sc_udev = dev;
        if ((err = usbd_device2interface_handle(dev, 0, &iface))) {
                DPRINTF(("%s: failed to get interface, err=%s\n",
                    sc->sc_dev.dv_xname, usbd_errstr(err)));
                goto fishy;
        }

        sc->sc_iface = iface;

        sc->sc_level = 0;
        sc->sc_minute = 0;
        sc->sc_last_mg = 0L;

        sc->sc_sync = 1;

        sc->sc_current = 0L;
        sc->sc_next = 0L;
        sc->sc_nrecv = 0;
        sc->sc_last = 0L;
        sc->sc_last_tv.tv_sec = 0L;

        switch (uaa->product) {
        case USB_PRODUCT_GUDE_DCF:
                if (udcf_nc_init_hw(sc))
                        goto fishy;
                break;
        case USB_PRODUCT_FTDI_DCF:
                if (udcf_ft232r_init_hw(sc))
                        goto fishy;
                break;
        }

        /* Give the receiver some slack to stabilize */
        timeout_add_msec(&sc->sc_to, T_WAIT);

        /* Detect signal loss */
        timeout_add_msec(&sc->sc_sl_to, T_WAIT + T_SL);

        DPRINTF(("synchronizing\n"));
        return;

fishy:
        DPRINTF(("udcf_attach failed\n"));
        usbd_deactivate(sc->sc_udev);
}

int
udcf_detach(struct device *self, int flags)
{
        struct udcf_softc       *sc = (struct udcf_softc *)self;

        if (timeout_initialized(&sc->sc_to))
                timeout_del(&sc->sc_to);
        if (timeout_initialized(&sc->sc_bv_to))
                timeout_del(&sc->sc_bv_to);
        if (timeout_initialized(&sc->sc_mg_to))
                timeout_del(&sc->sc_mg_to);
        if (timeout_initialized(&sc->sc_sl_to))
                timeout_del(&sc->sc_sl_to);
        if (timeout_initialized(&sc->sc_it_to))
                timeout_del(&sc->sc_it_to);

        /* Unregister the clock with the kernel */
        sensordev_deinstall(&sc->sc_sensordev);
        usb_rem_task(sc->sc_udev, &sc->sc_task);
        usb_rem_task(sc->sc_udev, &sc->sc_bv_task);
        usb_rem_task(sc->sc_udev, &sc->sc_mg_task);
        usb_rem_task(sc->sc_udev, &sc->sc_sl_task);

        return 0;
}

/* udcf_intr runs in an interrupt context */
void
udcf_intr(void *xsc)
{
        struct udcf_softc *sc = xsc;
        usb_add_task(sc->sc_udev, &sc->sc_task);
}

/* bit value detection */
void
udcf_bv_intr(void *xsc)
{
        struct udcf_softc *sc = xsc;
        usb_add_task(sc->sc_udev, &sc->sc_bv_task);
}

/* minute gap detection */
void
udcf_mg_intr(void *xsc)
{
        struct udcf_softc *sc = xsc;
        usb_add_task(sc->sc_udev, &sc->sc_mg_task);
}

/* signal loss detection */
void
udcf_sl_intr(void *xsc)
{
        struct udcf_softc *sc = xsc;
        usb_add_task(sc->sc_udev, &sc->sc_sl_task);
}

/*
 * initialize the Expert mouseCLOCK USB devices, they use a NetCologne
 * chip to interface the receiver.  Power must be supplied to the
 * receiver and the receiver must be turned on.
 */
int
udcf_nc_init_hw(struct udcf_softc *sc)
{
        usbd_status                      err;
        usb_device_request_t             req;
        uWord                            result;
        int                              actlen;

        /* Prepare the USB request to probe the value */
        sc->sc_req.bmRequestType = UT_READ_VENDOR_DEVICE;
        sc->sc_req.bRequest = 1;
        USETW(sc->sc_req.wValue, 0);
        USETW(sc->sc_req.wIndex, UDCF_READ_IDX);
        USETW(sc->sc_req.wLength, 1);

        req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
        req.bRequest = 0;
        USETW(req.wValue, 0);
        USETW(req.wIndex, 0);
        USETW(req.wLength, 0);
        if ((err = usbd_do_request_flags(sc->sc_udev, &req, &result,
            USBD_SHORT_XFER_OK, &actlen, USBD_DEFAULT_TIMEOUT))) {
                DPRINTF(("failed to turn on power for receiver\n"));
                return -1;
        }

        req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
        req.bRequest = 0;
        USETW(req.wValue, UDCF_CTRL_VAL);
        USETW(req.wIndex, UDCF_CTRL_IDX);
        USETW(req.wLength, 0);
        if ((err = usbd_do_request_flags(sc->sc_udev, &req, &result,
            USBD_SHORT_XFER_OK, &actlen, USBD_DEFAULT_TIMEOUT))) {
                DPRINTF(("failed to turn on receiver\n"));
                return -1;
        }
        return 0;
}

/*
 * initialize the Expert mouseCLOCK USB II devices, they use an FTDI
 * FT232R chip to interface the receiver.  Only reset the chip.
 */
int
udcf_ft232r_init_hw(struct udcf_softc *sc)
{
        usbd_status             err;
        usb_device_request_t    req;

        req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
        req.bRequest = FT232R_RESET;
        /* 0 resets the SIO */
        USETW(req.wValue,FT232R_RESET);
        USETW(req.wIndex, 0);
        USETW(req.wLength, 0);
        err = usbd_do_request(sc->sc_udev, &req, NULL);
        if (err) {
                DPRINTF(("failed to reset ftdi\n"));
                return -1;
        }
        return 0;
}

/*
 * return 1 during high-power-, 0 during low-power-emission
 * If bit 0 is set, the transmitter emits at full power.
 * During the low-power emission we decode a zero bit.
 */
int
udcf_nc_signal(struct udcf_softc *sc)
{
        int             actlen;
        unsigned char   data;

        if (usbd_do_request_flags(sc->sc_udev, &sc->sc_req, &data,
            USBD_SHORT_XFER_OK, &actlen, USBD_DEFAULT_TIMEOUT))
                /* This happens if we pull the receiver */
                return -1;
        return data & 0x01;
}

/* pick up the signal level through the FTDI FT232R chip */
int
udcf_ft232r_signal(struct udcf_softc *sc)
{
        usb_device_request_t    req;
        int                     actlen;
        u_int16_t               data;

        req.bmRequestType = UT_READ_VENDOR_DEVICE;
        req.bRequest = FT232R_STATUS;
        USETW(req.wValue, 0);
        USETW(req.wIndex, 0);
        USETW(req.wLength, 2);
        if (usbd_do_request_flags(sc->sc_udev, &req, &data,
            USBD_SHORT_XFER_OK, &actlen, USBD_DEFAULT_TIMEOUT)) {
                DPRINTFN(2, ("error reading ftdi modem status\n"));
                return -1;
        }
        DPRINTFN(2, ("ftdi status 0x%04x\n", data));
        return data & FT232R_RI ? 0 : 1;
}

/* udcf_probe runs in a process context. */
void
udcf_probe(void *xsc)
{
        struct udcf_softc       *sc = xsc;
        struct timespec          now;
        int                      data;

        if (usbd_is_dying(sc->sc_udev))
                return;

        data = sc->sc_signal(sc);
        if (data == -1)
                return;

        if (data) {
                sc->sc_level = 1;
                timeout_add(&sc->sc_to, 1);
                return;
        }

        if (sc->sc_level == 0)
                return;

        /* the beginning of a second */
        sc->sc_level = 0;
        if (sc->sc_minute == 1) {
                if (sc->sc_sync) {
                        DPRINTF(("start collecting bits\n"));
                        sc->sc_sync = 0;
                } else {
                        /* provide the timedelta */
                        microtime(&sc->sc_sensor.tv);
                        nanotime(&now);
                        sc->sc_current = sc->sc_next;
                        sc->sc_sensor.value = (int64_t)(now.tv_sec -
                            sc->sc_current) * 1000000000LL + now.tv_nsec;

                        sc->sc_sensor.status = SENSOR_S_OK;

                        /*
                         * if no valid time information is received
                         * during the next 5 minutes, the sensor state
                         * will be degraded to SENSOR_S_WARN
                         */
                        timeout_add_msec(&sc->sc_it_to, T_WARN);
                }
                sc->sc_minute = 0;
        }

        timeout_add_msec(&sc->sc_to, T_SYNC);   /* resync in 950 ms */

        /* no clock and bit detection during sync */
        if (!sc->sc_sync) {
                /* detect bit value */
                timeout_add_msec(&sc->sc_bv_to, T_BV);
        }
        timeout_add_msec(&sc->sc_mg_to, T_MG);  /* detect minute gap */
        timeout_add_msec(&sc->sc_sl_to, T_SL);  /* detect signal loss */
}

/* detect the bit value */
void
udcf_bv_probe(void *xsc)
{
        struct udcf_softc       *sc = xsc;
        int                      data;

        if (usbd_is_dying(sc->sc_udev))
                return;

        data = sc->sc_signal(sc);
        if (data == -1) {
                DPRINTF(("bit detection failed\n"));
                return;
        }       

        DPRINTFN(1, (data ? "0" : "1"));
        if (!(data))
                sc->sc_tbits |= sc->sc_mask;
        sc->sc_mask <<= 1;
}

/* detect the minute gap */
void
udcf_mg_probe(void *xsc)
{
        struct udcf_softc       *sc = xsc;
        struct clock_ymdhms      ymdhm;
        struct timeval           monotime;
        int                      tdiff_recv, tdiff_local;
        int                      skew;
        int                      minute_bits, hour_bits, day_bits;
        int                      month_bits, year_bits, wday;
        int                      p1, p2, p3;
        int                      p1_bit, p2_bit, p3_bit;
        int                      r_bit, a1_bit, a2_bit, z1_bit, z2_bit;
        int                      s_bit, m_bit;
        u_int32_t                parity = 0x6996;

        if (sc->sc_sync) {
                sc->sc_minute = 1;
                goto cleanbits;
        }

        if (gettime() - sc->sc_last_mg < 57) {
                DPRINTF(("\nunexpected gap, resync\n"));
                sc->sc_sync = sc->sc_minute = 1;
                goto cleanbits; 
        }

        /* extract bits w/o parity */
        m_bit = sc->sc_tbits & 1;
        r_bit = sc->sc_tbits >> 15 & 1;
        a1_bit = sc->sc_tbits >> 16 & 1;
        z1_bit = sc->sc_tbits >> 17 & 1;
        z2_bit = sc->sc_tbits >> 18 & 1;
        a2_bit = sc->sc_tbits >> 19 & 1;
        s_bit = sc->sc_tbits >> 20 & 1;
        p1_bit = sc->sc_tbits >> 28 & 1;
        p2_bit = sc->sc_tbits >> 35 & 1;
        p3_bit = sc->sc_tbits >> 58 & 1;

        minute_bits = sc->sc_tbits >> 21 & 0x7f;        
        hour_bits = sc->sc_tbits >> 29 & 0x3f;
        day_bits = sc->sc_tbits >> 36 & 0x3f;
        wday = (sc->sc_tbits >> 42) & 0x07;
        month_bits = sc->sc_tbits >> 45 & 0x1f;
        year_bits = sc->sc_tbits >> 50 & 0xff;

        /* validate time information */
        p1 = (parity >> (minute_bits & 0x0f) & 1) ^
            (parity >> (minute_bits >> 4) & 1);

        p2 = (parity >> (hour_bits & 0x0f) & 1) ^
            (parity >> (hour_bits >> 4) & 1);

        p3 = (parity >> (day_bits & 0x0f) & 1) ^
            (parity >> (day_bits >> 4) & 1) ^
            ((parity >> wday) & 1) ^ (parity >> (month_bits & 0x0f) & 1) ^
            (parity >> (month_bits >> 4) & 1) ^
            (parity >> (year_bits & 0x0f) & 1) ^
            (parity >> (year_bits >> 4) & 1);

        if (m_bit == 0 && s_bit == 1 && p1 == p1_bit && p2 == p2_bit &&
            p3 == p3_bit && (z1_bit ^ z2_bit)) {

                /* Decode time */
                if ((ymdhm.dt_year = 2000 + FROMBCD(year_bits)) > 2037) {
                        DPRINTF(("year out of range, resync\n"));
                        sc->sc_sync = 1;
                        goto cleanbits;
                }
                ymdhm.dt_min = FROMBCD(minute_bits);
                ymdhm.dt_hour = FROMBCD(hour_bits);
                ymdhm.dt_day = FROMBCD(day_bits);
                ymdhm.dt_mon = FROMBCD(month_bits);
                ymdhm.dt_sec = 0;

                sc->sc_next = clock_ymdhms_to_secs(&ymdhm);
                getmicrouptime(&monotime);

                /* convert to coordinated universal time */
                sc->sc_next -= z1_bit ? 7200 : 3600;

                DPRINTF(("\n%02d.%02d.%04d %02d:%02d:00 %s",
                    ymdhm.dt_day, ymdhm.dt_mon, ymdhm.dt_year,
                    ymdhm.dt_hour, ymdhm.dt_min, z1_bit ? "CEST" : "CET"));
                DPRINTF((r_bit ? ", call bit" : ""));
                DPRINTF((a1_bit ? ", dst chg ann." : ""));
                DPRINTF((a2_bit ? ", leap sec ann." : ""));
                DPRINTF(("\n"));

                if (sc->sc_last) {
                        tdiff_recv = sc->sc_next - sc->sc_last;
                        tdiff_local = monotime.tv_sec - sc->sc_last_tv.tv_sec;
                        skew = abs(tdiff_local - tdiff_recv);
#ifdef UDCF_DEBUG
                        if (sc->sc_skew.status == SENSOR_S_UNKNOWN)
                                sc->sc_skew.status = SENSOR_S_CRIT;
                        sc->sc_skew.value = skew * 1000000000LL;
                        getmicrotime(&sc->sc_skew.tv);
#endif
                        DPRINTF(("local = %d, recv = %d, skew = %d\n",
                            tdiff_local, tdiff_recv, skew));

                        if (skew && skew * 100LL / tdiff_local > MAX_SKEW) {
                                DPRINTF(("skew out of tolerated range\n"));
                                goto cleanbits;
                        } else {
                                if (sc->sc_nrecv < 2) {
                                        sc->sc_nrecv++;
                                        DPRINTF(("got frame %d\n",
                                            sc->sc_nrecv));
                                } else {
                                        DPRINTF(("data is valid\n"));
                                        sc->sc_minute = 1;
                                }
                        }
                } else {
                        DPRINTF(("received the first frame\n"));
                        sc->sc_nrecv = 1;
                }

                /* record the time received and when it was received */
                sc->sc_last = sc->sc_next;
                sc->sc_last_tv.tv_sec = monotime.tv_sec;
        } else {
                DPRINTF(("\nparity error, resync\n"));
                sc->sc_sync = sc->sc_minute = 1;
        }

cleanbits:
        timeout_add_msec(&sc->sc_to, T_MGSYNC); /* re-sync in 450 ms */
        sc->sc_last_mg = gettime();
        sc->sc_tbits = 0LL;
        sc->sc_mask = 1LL;
}

/* detect signal loss */
void
udcf_sl_probe(void *xsc)
{
        struct udcf_softc *sc = xsc;

        if (usbd_is_dying(sc->sc_udev))
                return;

        DPRINTF(("no signal\n"));
        sc->sc_sync = 1;
        timeout_add_msec(&sc->sc_to, T_WAIT);
        timeout_add_msec(&sc->sc_sl_to, T_WAIT + T_SL);
}

/* invalidate timedelta (called in an interrupt context) */
void
udcf_it_intr(void *xsc)
{
        struct udcf_softc *sc = xsc;

        if (usbd_is_dying(sc->sc_udev))
                return;

        if (sc->sc_sensor.status == SENSOR_S_OK) {
                sc->sc_sensor.status = SENSOR_S_WARN;
                /*
                 * further degrade in 15 minutes if we dont receive any new
                 * time information
                 */
                timeout_add_msec(&sc->sc_it_to, T_CRIT);
        } else {
                sc->sc_sensor.status = SENSOR_S_CRIT;
                sc->sc_nrecv = 0;
        }
}