int
ukbd_enable(void *v, int on)
{
struct ukbd_softc *sc = v;
if (on && sc->sc_dying)
return (EIO);
/* Should only be called to change state */
if (sc->sc_enabled == on) {
#ifdef DIAGNOSTIC
printf("ukbd_enable: %s: bad call on=%d\n",
USBDEVNAME(sc->sc_hdev.sc_dev), on);
#endif
return (EBUSY);
}
DPRINTF(("ukbd_enable: sc=%p on=%d\n", sc, on));
sc->sc_enabled = on;
if (on) {
return (uhidev_open(&sc->sc_hdev));
} else {
uhidev_close(&sc->sc_hdev);
return (0);
}
}
int
uhidopen(dev_t dev, int flag, int mode, struct proc *p)
{
struct uhid_softc *sc;
int error;
if (UHIDUNIT(dev) >= uhid_cd.cd_ndevs)
return (ENXIO);
sc = uhid_cd.cd_devs[UHIDUNIT(dev)];
if (sc == NULL)
return (ENXIO);
DPRINTF(("uhidopen: sc=%p\n", sc));
if (sc->sc_dying)
return (ENXIO);
error = uhidev_open(&sc->sc_hdev);
if (error)
return (error);
clalloc(&sc->sc_q, UHID_BSIZE, 0);
sc->sc_obuf = malloc(sc->sc_hdev.sc_osize, M_USBDEV, M_WAITOK);
sc->sc_state &= ~UHID_IMMED;
sc->sc_async = NULL;
return (0);
}
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);
sc->sc_flen = hid_report_size(desc, size, hid_feature, repid);
err = uhidev_open(&sc->sc_hdev);
if (err) {
printf("utwitch_open: uhidev_open %d\n", 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
ums_enable(void *v)
{
struct ums_softc *sc = v;
struct hidms *ms = &sc->sc_ms;
int rv;
if (usbd_is_dying(sc->sc_hdev.sc_udev))
return EIO;
if ((rv = hidms_enable(ms)) != 0)
return rv;
return uhidev_open(&sc->sc_hdev);
}
int
ums_enable(void *v)
{
struct ums_softc *sc = v;
DPRINTFN(1,("ums_enable: sc=%p\n", sc));
if (sc->sc_dying)
return (EIO);
if (sc->sc_enabled)
return (EBUSY);
sc->sc_enabled = 1;
sc->sc_buttons = 0;
return (uhidev_open(&sc->sc_hdev));
}
int
utpms_enable(void *v)
{
struct utpms_softc *sc = v;
/* Check that we are not detaching or already enabled. */
if (sc->sc_status & usbd_is_dying(sc->sc_hdev.sc_udev))
return (EIO);
if (sc->sc_status & UTPMS_ENABLED)
return (EBUSY);
sc->sc_status |= UTPMS_ENABLED;
sc->sc_status &= ~UTPMS_VALID;
sc->sc_buttons = 0;
bzero(sc->sc_sample, sizeof(sc->sc_sample));
return (uhidev_open(&sc->sc_hdev));
}
Static int
tpms_enable(void *v)
{
struct tpms_softc *sc = v;
/* Check that we are not detaching or already enabled. */
if (sc->sc_status & TPMS_DYING)
return (EIO);
if (sc->sc_status & TPMS_ENABLED)
return (EBUSY);
sc->sc_status |= TPMS_ENABLED;
sc->sc_status &= ~TPMS_VALID;
sc->sc_buttons = 0;
memset(sc->sc_sample, 0, sizeof(sc->sc_sample));
return (uhidev_open(&sc->sc_hdev));
}
Static int
uts_enable(void *v)
{
struct uts_softc *sc = v;
DPRINTFN(1,("uts_enable: sc=%p\n", sc));
if (sc->sc_dying)
return EIO;
if (sc->sc_enabled)
return EBUSY;
sc->sc_enabled = 1;
sc->sc_buttons = 0;
return uhidev_open(&sc->sc_hdev);
}
int
ukbd_enable(void *v, int on)
{
struct ukbd_softc *sc = v;
struct hidkbd *kbd = &sc->sc_kbd;
int rv;
if (on && usbd_is_dying(sc->sc_hdev.sc_udev))
return EIO;
if ((rv = hidkbd_enable(kbd, on)) != 0)
return rv;
if (on) {
return uhidev_open(&sc->sc_hdev);
} else {
uhidev_close(&sc->sc_hdev);
return 0;
}
}
int
ukbd_enable(void *v, int on)
{
struct ukbd_softc *sc = v;
if (on && sc->sc_dying)
return (EIO);
/* Should only be called to change state */
if (sc->sc_enabled == on) {
DPRINTF(("ukbd_enable: %s: bad call on=%d\n",
sc->sc_hdev.sc_dev.dv_xname, on));
return (EBUSY);
}
DPRINTF(("ukbd_enable: sc=%p on=%d\n", sc, on));
sc->sc_enabled = on;
if (on) {
return (uhidev_open(&sc->sc_hdev));
} else {
uhidev_close(&sc->sc_hdev);
return (0);
}
}
void
uoakv_attach(struct device *parent, struct device *self, void *aux)
{
struct uoakv_softc *sc = (struct uoakv_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;
struct uoak_softc *scc = &sc->sc_uoak_softc;
int i, err, size, repid;
void *desc;
sc->sc_hdev.sc_intr = uoakv_intr;
sc->sc_hdev.sc_parent = uha->parent;
sc->sc_hdev.sc_report_id = uha->reportid;
scc->sc_parent = sc;
scc->sc_udev = dev;
scc->sc_hdev = &sc->sc_hdev;
scc->sc_methods = &uoakv_methods;
scc->sc_sensordev = &sc->sc_sensordev;
uhidev_get_report_desc(uha->parent, &desc, &size);
repid = uha->reportid;
scc->sc_ilen = hid_report_size(desc, size, hid_input, repid);
scc->sc_olen = hid_report_size(desc, size, hid_output, repid);
scc->sc_flen = hid_report_size(desc, size, hid_feature, repid);
/* device initialize */
(void)uoak_led_ctrl(scc, OAK_TARGET_RAM, OAK_LED_ON);
err = uoak_set_sample_rate(scc, OAK_TARGET_RAM, UOAKV_SAMPLE_RATE);
if (err) {
printf("%s: could not set sampling rate. exit\n",
sc->sc_hdev.sc_dev.dv_xname);
return;
}
/* query and print device setting */
uoak_get_devinfo(scc);
uoak_print_devinfo(scc);
DPRINTF((" config in RAM\n"));
uoak_get_setting(scc, OAK_TARGET_RAM);
uoak_print_setting(scc, OAK_TARGET_RAM);
#ifdef UOAKV_DEBUG
DPRINTF((" config in FRASH\n"));
uoak_get_setting(scc, OAK_TARGET_FLASH);
uoak_print_setting(scc, OAK_TARGET_FLASH);
#endif
/* attach sensor */
strlcpy(sc->sc_sensordev.xname, sc->sc_hdev.sc_dev.dv_xname,
sizeof(sc->sc_sensordev.xname));
for (i = 0; i < OAK_V_MAXSENSORS; i++)
uoak_sensor_attach(scc, &sc->sc_sensor[i].v, SENSOR_VOLTS_DC);
/* start sensor */
sc->sc_sensortask = sensor_task_register(sc, uoakv_refresh,
UOAKV_REFRESH_PERIOD);
if (sc->sc_sensortask == NULL) {
printf(", unable to register update task\n");
return;
}
sensordev_install(&sc->sc_sensordev);
err = uhidev_open(&sc->sc_hdev);
if (err) {
printf("%s: could not open interrupt pipe, quit\n",
sc->sc_hdev.sc_dev.dv_xname);
return;
}
scc->sc_ibuf = malloc(scc->sc_ilen, M_USBDEV, M_WAITOK);
DPRINTF(("uoakv_attach: complete\n"));
}
void
uyurex_attach(device_t parent, device_t self, void *aux)
{
struct uyurex_softc *sc = device_private(self);
struct usb_attach_arg *uaa = aux;
struct uhidev_attach_arg *uha = (struct uhidev_attach_arg *)uaa;
usbd_device_handle dev = uha->parent->sc_udev;
int size, repid, err;
void *desc;
sc->sc_udev = dev;
sc->sc_hdev.sc_dev = self;
sc->sc_hdev.sc_intr = uyurex_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);
sc->sc_flen = hid_report_size(desc, size, hid_feature, repid);
aprint_normal("\n");
aprint_naive("\n");
err = uhidev_open(&sc->sc_hdev);
if (err) {
aprint_error_dev(self, "uyurex_open: uhidev_open %d\n", err);
return;
}
sc->sc_ibuf = malloc(sc->sc_ilen, M_USBDEV, M_WAITOK);
usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev,
sc->sc_hdev.sc_dev);
/* attach sensor */
sc->sc_sme = sysmon_envsys_create();
/* error handling? XXX */
sc->sc_sme->sme_name = device_xname(self);
/* add BBU sensor */
sc->sc_sensor_val.units = ENVSYS_INTEGER;
sc->sc_sensor_val.state = ENVSYS_SINVALID;
sc->sc_sensor_val.flags = ENVSYS_FMONCRITICAL; /* abuse XXX */
strlcpy(sc->sc_sensor_val.desc, "BBU",
sizeof(sc->sc_sensor_val.desc));
sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensor_val);
/* add BBU delta sensor */
sc->sc_sensor_delta.units = ENVSYS_INTEGER;
sc->sc_sensor_delta.state = ENVSYS_SINVALID;
strlcpy(sc->sc_sensor_delta.desc, "mBBU/sec",
sizeof(sc->sc_sensor_delta.desc));
sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensor_delta);
sc->sc_sme->sme_cookie = sc;
sc->sc_sme->sme_refresh = uyurex_refresh;
sc->sc_sme->sme_events_timeout = UPDATE_TICK;
sc->sc_sme->sme_flags = SME_INIT_REFRESH;
if (sysmon_envsys_register(sc->sc_sme)) {
aprint_error_dev(self, "unable to register with sysmon\n");
sysmon_envsys_destroy(sc->sc_sme);
}
callout_init(&sc->sc_deltach, 0);
callout_reset(&sc->sc_deltach, UPDATE_TICK * hz, uyurex_delta, sc);
DPRINTF(("uyurex_attach: complete\n"));
/* init device */ /* XXX */
uyurex_set_mode(sc, 0);
}
void
uslhcom_attach(struct device *parent, struct device *self, void *aux)
{
struct uslhcom_softc *sc = (struct uslhcom_softc *)self;
struct uhidev_attach_arg *uha = aux;
struct usbd_device *dev = uha->parent->sc_udev;
struct ucom_attach_args uca;
struct uslhcom_version_info version;
int err, repid, size, rsize;
void *desc;
sc->sc_udev = dev;
sc->sc_lsr = sc->sc_msr = 0;
sc->sc_hdev.sc_intr = uslhcom_intr;
sc->sc_hdev.sc_parent = uha->parent;
sc->sc_hdev.sc_report_id = uha->reportid;
sc->sc_hdev.sc_isize = sc->sc_hdev.sc_osize = sc->sc_hdev.sc_fsize = 0;
uhidev_get_report_desc(uha->parent, &desc, &size);
for (repid = 0; repid < uha->parent->sc_nrepid; repid++) {
rsize = hid_report_size(desc, size, hid_input, repid);
if (sc->sc_hdev.sc_isize < rsize) sc->sc_hdev.sc_isize = rsize;
rsize = hid_report_size(desc, size, hid_output, repid);
if (sc->sc_hdev.sc_osize < rsize) sc->sc_hdev.sc_osize = rsize;
rsize = hid_report_size(desc, size, hid_feature, repid);
if (sc->sc_hdev.sc_fsize < rsize) sc->sc_hdev.sc_fsize = rsize;
}
printf("\n");
err = uhidev_open(&sc->sc_hdev);
if (err) {
DPRINTF(("uslhcom_attach: uhidev_open %d\n", err));
return;
}
DPRINTF(("uslhcom_attach: sc %p opipe %p ipipe %p report_id %d\n",
sc, sc->sc_hdev.sc_parent->sc_opipe,
sc->sc_hdev.sc_parent->sc_ipipe, uha->reportid));
DPRINTF(("uslhcom_attach: isize %d osize %d fsize %d\n",
sc->sc_hdev.sc_isize, sc->sc_hdev.sc_osize,
sc->sc_hdev.sc_fsize));
uslhcom_uart_endis(sc, UART_DISABLE);
uslhcom_get_version(sc, &version);
printf("%s: pid %#x rev %#x\n", sc->sc_hdev.sc_dev.dv_xname,
version.product_id, version.product_revision);
/* setup ucom layer */
uca.portno = UCOM_UNK_PORTNO;
uca.bulkin = uca.bulkout = -1;
uca.ibufsize = uca.ibufsizepad = 0;
uca.obufsize = sc->sc_hdev.sc_osize;
uca.opkthdrlen = USLHCOM_TX_HEADER_SIZE;
uca.uhidev = sc->sc_hdev.sc_parent;
uca.device = uha->uaa->device;
uca.iface = uha->uaa->iface;
uca.methods = &uslhcom_methods;
uca.arg = sc;
uca.info = NULL;
sc->sc_subdev = config_found_sm(self, &uca, ucomprint, ucomsubmatch);
}
