uthum.c revision 1.4
1 /* $NetBSD: uthum.c,v 1.4 2010/03/07 11:28:46 jdc Exp $ */ 2 /* $OpenBSD: uthum.c,v 1.6 2010/01/03 18:43:02 deraadt Exp $ */ 3 4 /* 5 * Copyright (c) 2009 Yojiro UO <yuo (at) nui.org> 6 * 7 * Permission to use, copy, modify, and distribute this software for any 8 * purpose with or without fee is hereby granted, provided that the above 9 * copyright notice and this permission notice appear in all copies. 10 * 11 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCAIMS ALL WARRANTIES 12 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 13 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 14 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 15 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 16 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 17 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 18 */ 19 20 /* Driver for TEMPer and TEMPerHUM HID */ 21 22 #include <sys/param.h> 23 #include <sys/proc.h> 24 #include <sys/systm.h> 25 #include <sys/kernel.h> 26 #include <sys/malloc.h> 27 #include <sys/device.h> 28 #include <sys/conf.h> 29 30 #include <dev/sysmon/sysmonvar.h> 31 32 #include <dev/usb/usb.h> 33 #include <dev/usb/usbhid.h> 34 #include <dev/usb/usbdi.h> 35 #include <dev/usb/usbdi_util.h> 36 #include <dev/usb/usbdevs.h> 37 #include <dev/usb/uhidev.h> 38 #include <dev/usb/hid.h> 39 40 #ifdef USB_DEBUG 41 #define UTHUM_DEBUG 42 #endif 43 44 #ifdef UTHUM_DEBUG 45 int uthumdebug = 0; 46 #define DPRINTFN(n, x) do { if (uthumdebug > (n)) printf x; } while (0) 47 #else 48 #define DPRINTFN(n, x) 49 #endif 50 51 #define DPRINTF(x) DPRINTFN(0, x) 52 53 54 /* TEMPerHUM */ 55 #define CMD_DEVTYPE 0x52 /* XXX */ 56 #define CMD_GETDATA 0x48 /* XXX */ 57 #define CMD_GETTEMP 0x54 /* XXX */ 58 static uint8_t cmd_start[8] = 59 { 0x0a, 0x0b, 0x0c, 0x0d, 0x00, 0x00, 0x02, 0x00 }; 60 static uint8_t cmd_end[8] = 61 { 0x0a, 0x0b, 0x0c, 0x0d, 0x00, 0x00, 0x01, 0x00 }; 62 63 /* sensors */ 64 #define UTHUM_TEMP 0 65 #define UTHUM_HUMIDITY 1 66 #define UTHUM_MAX_SENSORS 2 67 68 #define UTHUM_TYPE_UNKNOWN 0 69 #define UTHUM_TYPE_SHT1x 1 70 #define UTHUM_TYPE_TEMPER 2 71 72 struct uthum_softc { 73 struct uhidev sc_hdev; 74 usbd_device_handle sc_udev; 75 u_char sc_dying; 76 uint16_t sc_flag; 77 int sc_sensortype; 78 79 /* uhidev parameters */ 80 size_t sc_flen; /* feature report length */ 81 size_t sc_ilen; /* input report length */ 82 size_t sc_olen; /* output report length */ 83 84 /* sensor framework */ 85 struct sysmon_envsys *sc_sme; 86 envsys_data_t sc_sensor[UTHUM_MAX_SENSORS]; 87 88 uint8_t sc_num_sensors; 89 }; 90 91 92 const struct usb_devno uthum_devs[] = { 93 /* XXX: various TEMPer variants using same VID/PID */ 94 { USB_VENDOR_TENX, USB_PRODUCT_TENX_TEMPER}, 95 }; 96 #define uthum_lookup(v, p) usb_lookup(uthum_devs, v, p) 97 98 int uthum_match(device_t, cfdata_t, void *); 99 void uthum_attach(device_t, device_t, void *); 100 void uthum_childdet(device_t, device_t); 101 int uthum_detach(device_t, int); 102 int uthum_activate(device_t, enum devact); 103 104 int uthum_read_data(struct uthum_softc *, uint8_t, uint8_t *, size_t, int); 105 int uthum_check_sensortype(struct uthum_softc *); 106 int uthum_sht1x_temp(unsigned int); 107 int uthum_sht1x_rh(unsigned int, int); 108 109 void uthum_intr(struct uhidev *, void *, u_int); 110 static void uthum_refresh(struct sysmon_envsys *, envsys_data_t *); 111 112 extern struct cfdriver uthum_cd; 113 CFATTACH_DECL_NEW(uthum, sizeof(struct uthum_softc), uthum_match, uthum_attach, 114 uthum_detach, uthum_activate); 115 116 USB_MATCH(uthum) 117 { 118 USB_MATCH_START(uthum, uaa); 119 struct uhidev_attach_arg *uha = (struct uhidev_attach_arg *)uaa; 120 121 return (uthum_lookup(uha->uaa->vendor, uha->uaa->product) != NULL ? 122 UMATCH_VENDOR_PRODUCT : UMATCH_NONE); 123 } 124 125 USB_ATTACH(uthum) 126 { 127 USB_ATTACH_START(uthum, sc, uaa); 128 struct uhidev_attach_arg *uha = (struct uhidev_attach_arg *)uaa; 129 usbd_device_handle dev = uha->parent->sc_udev; 130 int size, repid; 131 void *desc; 132 133 sc->sc_udev = dev; 134 sc->sc_hdev.sc_dev = self; 135 sc->sc_hdev.sc_intr = uthum_intr; 136 sc->sc_hdev.sc_parent = uha->parent; 137 sc->sc_hdev.sc_report_id = uha->reportid; 138 sc->sc_num_sensors = 0; 139 140 aprint_normal("\n"); 141 aprint_naive("\n"); 142 143 uhidev_get_report_desc(uha->parent, &desc, &size); 144 repid = uha->reportid; 145 sc->sc_ilen = hid_report_size(desc, size, hid_input, repid); 146 sc->sc_olen = hid_report_size(desc, size, hid_output, repid); 147 sc->sc_flen = hid_report_size(desc, size, hid_feature, repid); 148 149 usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev, 150 sc->sc_hdev.sc_dev); 151 152 if (sc->sc_flen < 32) { 153 /* not sensor interface, just attach */ 154 return; 155 } 156 157 sc->sc_sensortype = uthum_check_sensortype(sc); 158 159 /* attach sensor */ 160 sc->sc_sme = sysmon_envsys_create(); 161 sc->sc_sme->sme_name = device_xname(self); 162 163 switch (sc->sc_sensortype) { 164 case UTHUM_TYPE_SHT1x: 165 (void)strlcpy(sc->sc_sensor[UTHUM_TEMP].desc, "temp", 166 sizeof(sc->sc_sensor[UTHUM_TEMP].desc)); 167 sc->sc_sensor[UTHUM_TEMP].units = ENVSYS_STEMP; 168 sc->sc_sensor[UTHUM_TEMP].state = ENVSYS_SINVALID; 169 170 (void)strlcpy(sc->sc_sensor[UTHUM_HUMIDITY].desc, 171 "relative humidity", 172 sizeof(sc->sc_sensor[UTHUM_HUMIDITY].desc)); 173 sc->sc_sensor[UTHUM_HUMIDITY].units = ENVSYS_INTEGER; 174 sc->sc_sensor[UTHUM_HUMIDITY].value_cur = 0; 175 sc->sc_sensor[UTHUM_HUMIDITY].state = ENVSYS_SINVALID; 176 177 sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensor[UTHUM_TEMP]); 178 sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensor[UTHUM_HUMIDITY]); 179 sc->sc_num_sensors = 2; 180 DPRINTF(("sensor type: SHT1x\n")); 181 break; 182 case UTHUM_TYPE_TEMPER: 183 (void)strlcpy(sc->sc_sensor[UTHUM_TEMP].desc, "temp", 184 sizeof(sc->sc_sensor[UTHUM_TEMP].desc)); 185 sc->sc_sensor[UTHUM_TEMP].units = ENVSYS_STEMP; 186 sc->sc_sensor[UTHUM_TEMP].state = ENVSYS_SINVALID; 187 188 sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensor[UTHUM_TEMP]); 189 sc->sc_num_sensors = 1; 190 DPRINTF(("sensor type: TEMPer\n")); 191 break; 192 case UTHUM_TYPE_UNKNOWN: 193 DPRINTF(("sensor type: unknown, give up to attach sensors\n")); 194 default: 195 break; 196 } 197 198 if (sc->sc_num_sensors > 0) { 199 sc->sc_sme->sme_cookie = sc; 200 sc->sc_sme->sme_refresh = uthum_refresh; 201 202 if (sysmon_envsys_register(sc->sc_sme)) { 203 aprint_error_dev(self, "unable to register with sysmon\n"); 204 sysmon_envsys_destroy(sc->sc_sme); 205 } 206 } else { 207 sysmon_envsys_destroy(sc->sc_sme); 208 } 209 210 DPRINTF(("uthum_attach: complete\n")); 211 } 212 213 USB_DETACH(uthum) 214 { 215 USB_DETACH_START(uthum, sc); 216 int rv = 0; 217 218 sc->sc_dying = 1; 219 220 if (sc->sc_num_sensors > 0) { 221 sysmon_envsys_unregister(sc->sc_sme); 222 } 223 224 usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev, 225 sc->sc_hdev.sc_dev); 226 227 return (rv); 228 } 229 230 int 231 uthum_activate(device_t self, enum devact act) 232 { 233 struct uthum_softc *sc = device_private(self); 234 235 switch (act) { 236 case DVACT_DEACTIVATE: 237 sc->sc_dying = 1; 238 break; 239 } 240 return (0); 241 } 242 243 void 244 uthum_intr(struct uhidev *addr, void *ibuf, u_int len) 245 { 246 /* do nothing */ 247 } 248 249 int 250 uthum_read_data(struct uthum_softc *sc, uint8_t target_cmd, uint8_t *buf, 251 size_t len, int need_delay) 252 { 253 int i; 254 uint8_t cmdbuf[32], report[256]; 255 256 /* if return buffer is null, do nothing */ 257 if ((buf == NULL) || len == 0) 258 return 0; 259 260 /* issue query */ 261 bzero(cmdbuf, sizeof(cmdbuf)); 262 memcpy(cmdbuf, cmd_start, sizeof(cmd_start)); 263 if (uhidev_set_report(&sc->sc_hdev, UHID_OUTPUT_REPORT, 264 cmdbuf, sc->sc_olen)) 265 return EIO; 266 267 bzero(cmdbuf, sizeof(cmdbuf)); 268 cmdbuf[0] = target_cmd; 269 if (uhidev_set_report(&sc->sc_hdev, UHID_OUTPUT_REPORT, 270 cmdbuf, sc->sc_olen)) 271 return EIO; 272 273 bzero(cmdbuf, sizeof(cmdbuf)); 274 for (i = 0; i < 7; i++) { 275 if (uhidev_set_report(&sc->sc_hdev, UHID_OUTPUT_REPORT, 276 cmdbuf, sc->sc_olen)) 277 return EIO; 278 } 279 memcpy(cmdbuf, cmd_end, sizeof(cmd_end)); 280 if (uhidev_set_report(&sc->sc_hdev, UHID_OUTPUT_REPORT, 281 cmdbuf, sc->sc_olen)) 282 return EIO; 283 284 /* wait if required */ 285 if (need_delay > 1) 286 tsleep(&sc->sc_sme, 0, "uthum", (need_delay*hz+999)/1000 + 1); 287 288 /* get answer */ 289 if (uhidev_get_report(&sc->sc_hdev, UHID_FEATURE_REPORT, 290 report, sc->sc_flen)) 291 return EIO; 292 memcpy(buf, report, len); 293 return 0; 294 } 295 296 int 297 uthum_check_sensortype(struct uthum_softc *sc) 298 { 299 uint8_t buf[8]; 300 static uint8_t sht1x_sig[] = 301 { 0x57, 0x5a, 0x13, 0x00, 0x14, 0x00, 0x53, 0x00 }; 302 static uint8_t temper_sig[] = 303 { 0x57, 0x58, 0x14, 0x00, 0x14, 0x00, 0x53, 0x00 }; 304 305 if (uthum_read_data(sc, CMD_DEVTYPE, buf, sizeof(buf), 0) != 0) { 306 DPRINTF(("uthum: read fail\n")); 307 return UTHUM_TYPE_UNKNOWN; 308 } 309 310 /* 311 * currently we have not enough information about the return value, 312 * therefore, compare full bytes. 313 * TEMPerHUM HID (SHT1x version) will return: 314 * { 0x57, 0x5a, 0x13, 0x00, 0x14, 0x00, 0x53, 0x00 } 315 * TEMPer HID (SHT1x version) will return: 316 * { 0x57, 0x58, 0x14, 0x00, 0x14, 0x00, 0x53, 0x00 } 317 */ 318 if (0 == memcmp(buf, sht1x_sig, sizeof(sht1x_sig))) 319 return UTHUM_TYPE_SHT1x; 320 if (0 == memcmp(buf, temper_sig, sizeof(temper_sig))) 321 return UTHUM_TYPE_TEMPER; 322 323 return UTHUM_TYPE_UNKNOWN; 324 } 325 326 327 static void 328 uthum_refresh(struct sysmon_envsys *sme, envsys_data_t *edata) 329 { 330 struct uthum_softc *sc = sme->sme_cookie; 331 uint8_t buf[8]; 332 unsigned int temp_tick, humidity_tick; 333 int temp, rh; 334 335 switch (sc->sc_sensortype) { 336 case UTHUM_TYPE_SHT1x: 337 if (uthum_read_data(sc, CMD_GETDATA, buf, sizeof(buf), 1000) != 0) { 338 DPRINTF(("uthum: data read fail\n")); 339 sc->sc_sensor[UTHUM_TEMP].state = ENVSYS_SINVALID; 340 sc->sc_sensor[UTHUM_HUMIDITY].state = ENVSYS_SINVALID; 341 return; 342 } 343 344 temp_tick = (buf[0] * 256 + buf[1]) & 0x3fff; 345 humidity_tick = (buf[2] * 256 + buf[3]) & 0x0fff; 346 347 temp = uthum_sht1x_temp(temp_tick); 348 rh = uthum_sht1x_rh(humidity_tick, temp); 349 350 sc->sc_sensor[UTHUM_HUMIDITY].value_cur = rh / 1000; 351 sc->sc_sensor[UTHUM_HUMIDITY].state = ENVSYS_SVALID; 352 break; 353 case UTHUM_TYPE_TEMPER: 354 if (uthum_read_data(sc, CMD_GETTEMP, buf, sizeof(buf), 0) != 0) { 355 DPRINTF(("uthum: data read fail\n")); 356 sc->sc_sensor[UTHUM_TEMP].state = ENVSYS_SINVALID; 357 return; 358 } 359 temp_tick = (buf[0] * 256 + buf[1]) & 0xffff; 360 temp = uthum_sht1x_temp(temp_tick); 361 break; 362 default: 363 /* do nothing */ 364 return; 365 } 366 367 sc->sc_sensor[UTHUM_TEMP].value_cur = (temp * 10000) + 273150000; 368 sc->sc_sensor[UTHUM_TEMP].state = ENVSYS_SVALID; 369 } 370 371 /* return C-degree * 100 value */ 372 int 373 uthum_sht1x_temp(unsigned int ticks) 374 { 375 return (ticks - 4010); 376 } 377 378 /* return %RH * 1000 */ 379 int 380 uthum_sht1x_rh(unsigned int ticks, int temp) 381 { 382 int rh_l, rh; 383 384 rh_l = (-40000 + 405 * ticks) - ((7 * ticks * ticks) / 250); 385 rh = ((temp - 2500) * (1 + (ticks >> 7)) + rh_l) / 10; 386 return rh; 387 } 388
Indexes created Wed Sep 24 05:09:52 GMT 2025