325 lines
8.2 KiB
C
325 lines
8.2 KiB
C
/* $OpenBSD: utwitch.c,v 1.23 2024/05/23 03:21:09 jsg Exp $ */
|
|
|
|
/*
|
|
* Copyright (c) 2010 Yojiro UO <yuo@nui.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 DISCAIMS 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.
|
|
*/
|
|
|
|
/* Driver for Maywa-Denki & KAYAC YUREX BBU sensor */
|
|
/* this driver was previously known as uyurex(4). */
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/malloc.h>
|
|
#include <sys/device.h>
|
|
#include <sys/sensors.h>
|
|
|
|
#include <dev/usb/usb.h>
|
|
#include <dev/usb/usbhid.h>
|
|
#include <dev/usb/usbdi.h>
|
|
#include <dev/usb/usbdevs.h>
|
|
#include <dev/usb/uhidev.h>
|
|
|
|
#define CMD_NONE 0xf0
|
|
#define CMD_EOF 0x0d
|
|
#define CMD_ACK 0x21
|
|
#define CMD_MODE 0x41 /* XXX */
|
|
#define CMD_VALUE 0x43
|
|
#define CMD_READ 0x52
|
|
#define CMD_WRITE 0x53
|
|
#define CMD_PADDING 0xff
|
|
|
|
#define UPDATE_TICK 5 /* sec */
|
|
|
|
#ifdef UYUREX_DEBUG
|
|
#define DPRINTF(x) do { printf x; } while (0)
|
|
#else
|
|
#define DPRINTF(x)
|
|
#endif
|
|
|
|
struct utwitch_softc {
|
|
struct uhidev sc_hdev;
|
|
struct usbd_device *sc_udev;
|
|
|
|
/* uhidev parameters */
|
|
size_t sc_ilen; /* input report length */
|
|
size_t sc_olen; /* output report length */
|
|
|
|
uint8_t *sc_ibuf;
|
|
|
|
/* sensor framework */
|
|
struct ksensor sc_sensor_val;
|
|
struct ksensor sc_sensor_delta;
|
|
struct ksensordev sc_sensordev;
|
|
struct sensor_task *sc_sensortask;
|
|
|
|
/* device private */
|
|
int sc_initialized;
|
|
uint8_t issueing_cmd;
|
|
uint8_t accepted_cmd;
|
|
|
|
uint32_t sc_curval;
|
|
uint32_t sc_oldval;
|
|
};
|
|
|
|
const struct usb_devno utwitch_devs[] = {
|
|
{ USB_VENDOR_MICRODIA, USB_PRODUCT_MICRODIA_YUREX},
|
|
};
|
|
|
|
int utwitch_match(struct device *, void *, void *);
|
|
void utwitch_attach(struct device *, struct device *, void *);
|
|
int utwitch_detach(struct device *, int);
|
|
|
|
void utwitch_set_mode(struct utwitch_softc *, uint8_t);
|
|
void utwitch_read_value_request(struct utwitch_softc *);
|
|
void utwitch_write_value_request(struct utwitch_softc *, uint32_t);
|
|
|
|
void utwitch_intr(struct uhidev *, void *, u_int);
|
|
void utwitch_refresh(void *);
|
|
|
|
struct cfdriver utwitch_cd = {
|
|
NULL, "utwitch", DV_DULL
|
|
};
|
|
|
|
const struct cfattach utwitch_ca = {
|
|
sizeof(struct utwitch_softc),
|
|
utwitch_match,
|
|
utwitch_attach,
|
|
utwitch_detach
|
|
};
|
|
|
|
int
|
|
utwitch_match(struct device *parent, void *match, void *aux)
|
|
{
|
|
struct uhidev_attach_arg *uha = aux;
|
|
|
|
if (UHIDEV_CLAIM_MULTIPLE_REPORTID(uha))
|
|
return (UMATCH_NONE);
|
|
|
|
return (usb_lookup(utwitch_devs, uha->uaa->vendor, uha->uaa->product) != NULL ?
|
|
UMATCH_VENDOR_PRODUCT : UMATCH_NONE);
|
|
}
|
|
|
|
void
|
|
utwitch_attach(struct device *parent, struct device *self, void *aux)
|
|
{
|
|
struct utwitch_softc *sc = (struct utwitch_softc *)self;
|
|
struct usb_attach_arg *uaa = aux;
|
|
struct uhidev_attach_arg *uha = (struct uhidev_attach_arg *)uaa;
|
|
struct usbd_device *dev = uha->parent->sc_udev;
|
|
int size, repid, err;
|
|
void *desc;
|
|
|
|
sc->sc_udev = dev;
|
|
sc->sc_hdev.sc_intr = utwitch_intr;
|
|
sc->sc_hdev.sc_parent = uha->parent;
|
|
sc->sc_hdev.sc_report_id = uha->reportid;
|
|
|
|
uhidev_get_report_desc(uha->parent, &desc, &size);
|
|
repid = uha->reportid;
|
|
sc->sc_ilen = hid_report_size(desc, size, hid_input, repid);
|
|
sc->sc_olen = hid_report_size(desc, size, hid_output, repid);
|
|
|
|
err = uhidev_open(&sc->sc_hdev);
|
|
if (err) {
|
|
printf("%s: uhidev_open %d\n", __func__, err);
|
|
return;
|
|
}
|
|
sc->sc_ibuf = malloc(sc->sc_ilen, M_USBDEV, M_WAITOK);
|
|
|
|
printf("\n");
|
|
|
|
|
|
/* attach sensor */
|
|
strlcpy(sc->sc_sensordev.xname, sc->sc_hdev.sc_dev.dv_xname,
|
|
sizeof(sc->sc_sensordev.xname));
|
|
|
|
/* add BBU sensor */
|
|
sc->sc_sensor_val.type = SENSOR_INTEGER;
|
|
sensor_attach(&sc->sc_sensordev, &sc->sc_sensor_val);
|
|
strlcpy(sc->sc_sensor_val.desc, "BBU",
|
|
sizeof(sc->sc_sensor_val.desc));
|
|
|
|
/* add BBU delta sensor */
|
|
sc->sc_sensor_delta.type = SENSOR_INTEGER;
|
|
sensor_attach(&sc->sc_sensordev, &sc->sc_sensor_delta);
|
|
strlcpy(sc->sc_sensor_delta.desc, "mBBU/sec",
|
|
sizeof(sc->sc_sensor_delta.desc));
|
|
|
|
sc->sc_sensortask = sensor_task_register(sc, utwitch_refresh, UPDATE_TICK);
|
|
if (sc->sc_sensortask == NULL) {
|
|
printf(", unable to register update task\n");
|
|
return;
|
|
}
|
|
sensordev_install(&sc->sc_sensordev);
|
|
|
|
DPRINTF(("utwitch_attach: complete\n"));
|
|
|
|
/* init device */ /* XXX */
|
|
utwitch_set_mode(sc, 0);
|
|
}
|
|
|
|
int
|
|
utwitch_detach(struct device *self, int flags)
|
|
{
|
|
struct utwitch_softc *sc = (struct utwitch_softc *)self;
|
|
int rv = 0;
|
|
|
|
wakeup(&sc->sc_sensortask);
|
|
sensordev_deinstall(&sc->sc_sensordev);
|
|
sensor_detach(&sc->sc_sensordev, &sc->sc_sensor_val);
|
|
sensor_detach(&sc->sc_sensordev, &sc->sc_sensor_delta);
|
|
if (sc->sc_sensortask != NULL)
|
|
sensor_task_unregister(sc->sc_sensortask);
|
|
|
|
if (sc->sc_hdev.sc_state & UHIDEV_OPEN)
|
|
uhidev_close(&sc->sc_hdev);
|
|
|
|
if (sc->sc_ibuf != NULL) {
|
|
free(sc->sc_ibuf, M_USBDEV, sc->sc_ilen);
|
|
sc->sc_ibuf = NULL;
|
|
}
|
|
|
|
return (rv);
|
|
}
|
|
|
|
void
|
|
utwitch_intr(struct uhidev *addr, void *ibuf, u_int len)
|
|
{
|
|
struct utwitch_softc *sc = (struct utwitch_softc *)addr;
|
|
uint8_t buf[8];
|
|
uint32_t val;
|
|
|
|
if (sc->sc_ibuf == NULL)
|
|
return;
|
|
|
|
/* process requests */
|
|
memcpy(buf, ibuf, 8);
|
|
DPRINTF(("intr: %.2x %.2x %.2x %.2x %.2x %.2x %.2x %.2x\n",
|
|
buf[0], buf[1], buf[2], buf[3],
|
|
buf[4], buf[5], buf[6], buf[7]));
|
|
|
|
|
|
switch (buf[0]) {
|
|
case CMD_ACK:
|
|
if (buf[1] == sc->issueing_cmd) {
|
|
DPRINTF(("ack received for cmd 0x%.2x\n", buf[1]));
|
|
sc->accepted_cmd = buf[1];
|
|
} else {
|
|
DPRINTF(("cmd-ack mismatch: recved 0x%.2x, expect 0x%.2x\n",
|
|
buf[1], sc->issueing_cmd));
|
|
/* discard previous command */
|
|
sc->accepted_cmd = CMD_NONE;
|
|
sc->issueing_cmd = CMD_NONE;
|
|
}
|
|
break;
|
|
case CMD_READ:
|
|
case CMD_VALUE:
|
|
val = (buf[2] << 24) + (buf[3] << 16) + (buf[4] << 8) + buf[5];
|
|
if (!sc->sc_initialized) {
|
|
sc->sc_oldval = val;
|
|
sc->sc_initialized = 1;
|
|
}
|
|
sc->sc_sensor_val.value = val;
|
|
sc->sc_curval = val;
|
|
DPRINTF(("recv value update message: %d\n", val));
|
|
break;
|
|
default:
|
|
DPRINTF(("unknown message: 0x%.2x\n", buf[0]));
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
void
|
|
utwitch_refresh(void *arg)
|
|
{
|
|
struct utwitch_softc *sc = arg;
|
|
|
|
if (!sc->sc_initialized) {
|
|
utwitch_read_value_request(sc);
|
|
} else {
|
|
/* calculate delta value */
|
|
sc->sc_sensor_delta.value =
|
|
(1000 * (sc->sc_curval - sc->sc_oldval)) / UPDATE_TICK;
|
|
sc->sc_oldval = sc->sc_curval;
|
|
}
|
|
}
|
|
|
|
void
|
|
utwitch_set_mode(struct utwitch_softc *sc, uint8_t val)
|
|
{
|
|
uint8_t req[8];
|
|
int olen;
|
|
|
|
olen = MIN(sc->sc_olen, sizeof(req));
|
|
memset(req, CMD_PADDING, sizeof(req));
|
|
req[0] = CMD_MODE;
|
|
req[1] = val;
|
|
req[2] = CMD_EOF;
|
|
if (uhidev_set_report(sc->sc_hdev.sc_parent, UHID_OUTPUT_REPORT,
|
|
sc->sc_hdev.sc_report_id, req, olen) != olen) {
|
|
printf("uhidev_set_report error:EIO\n");
|
|
return;
|
|
}
|
|
|
|
/* wait ack */
|
|
tsleep_nsec(&sc->sc_sensortask, 0, "utwitch", MSEC_TO_NSEC(1000));
|
|
}
|
|
|
|
void
|
|
utwitch_read_value_request(struct utwitch_softc *sc)
|
|
{
|
|
uint8_t req[8];
|
|
int olen;
|
|
|
|
olen = MIN(sc->sc_olen, sizeof(req));
|
|
memset(req, CMD_PADDING, sizeof(req));
|
|
req[0] = CMD_READ;
|
|
req[1] = CMD_EOF;
|
|
sc->issueing_cmd = CMD_READ;
|
|
sc->accepted_cmd = CMD_NONE;
|
|
if (uhidev_set_report(sc->sc_hdev.sc_parent, UHID_OUTPUT_REPORT,
|
|
sc->sc_hdev.sc_report_id, req, olen) != olen)
|
|
return;
|
|
|
|
/* wait till sensor data are updated, 500ms will be enough */
|
|
tsleep_nsec(&sc->sc_sensortask, 0, "utwitch", MSEC_TO_NSEC(500));
|
|
}
|
|
|
|
void
|
|
utwitch_write_value_request(struct utwitch_softc *sc, uint32_t val)
|
|
{
|
|
uint32_t v;
|
|
uint8_t req[8];
|
|
int olen;
|
|
|
|
olen = MIN(sc->sc_olen, sizeof(req));
|
|
req[0] = CMD_WRITE;
|
|
req[1] = 0;
|
|
req[6] = CMD_EOF;
|
|
req[7] = CMD_PADDING;
|
|
v = htobe32(val);
|
|
memcpy(req + 2, &v, sizeof(uint32_t));
|
|
|
|
sc->issueing_cmd = CMD_WRITE;
|
|
sc->accepted_cmd = CMD_NONE;
|
|
if (uhidev_set_report(sc->sc_hdev.sc_parent, UHID_OUTPUT_REPORT,
|
|
sc->sc_hdev.sc_report_id, req, olen) != olen)
|
|
return;
|
|
|
|
/* wait till sensor data are updated, 250ms will be enough */
|
|
tsleep_nsec(&sc->sc_sensortask, 0, "utwitch", MSEC_TO_NSEC(250));
|
|
}
|