1 /* $OpenBSD: upd.c,v 1.33 2024/12/01 09:05:05 landry Exp $ */ 2 3 /* 4 * Copyright (c) 2015 David Higgs <higgsd@gmail.com> 5 * Copyright (c) 2014 Andre de Oliveira <andre@openbsd.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 /* 21 * Driver for USB Power Devices sensors 22 * https://usb.org/sites/default/files/pdcv10.pdf 23 */ 24 25 #include <sys/param.h> 26 #include <sys/systm.h> 27 #include <sys/malloc.h> 28 #include <sys/device.h> 29 #include <sys/queue.h> 30 #include <sys/sensors.h> 31 32 #include <dev/usb/usb.h> 33 #include <dev/usb/usbdi.h> 34 #include <dev/usb/usbhid.h> 35 #include <dev/usb/uhidev.h> 36 37 #ifdef UPD_DEBUG 38 #define DPRINTF(x) do { printf x; } while (0) 39 #else 40 #define DPRINTF(x) 41 #endif 42 43 #define DEVNAME(sc) ((sc)->sc_hdev.sc_dev.dv_xname) 44 45 struct upd_usage_entry { 46 uint8_t usage_pg; 47 uint8_t usage_id; 48 enum sensor_type senstype; 49 char *usage_name; /* sensor string */ 50 int nchildren; 51 struct upd_usage_entry *children; 52 }; 53 54 static struct upd_usage_entry upd_usage_batdep[] = { 55 { HUP_BATTERY, HUB_REL_STATEOF_CHARGE, 56 SENSOR_PERCENT, "RelativeStateOfCharge" }, 57 { HUP_BATTERY, HUB_ABS_STATEOF_CHARGE, 58 SENSOR_PERCENT, "AbsoluteStateOfCharge" }, 59 { HUP_BATTERY, HUB_REM_CAPACITY, 60 SENSOR_PERCENT, "RemainingCapacity" }, 61 { HUP_BATTERY, HUB_FULLCHARGE_CAPACITY, 62 SENSOR_PERCENT, "FullChargeCapacity" }, 63 { HUP_POWER, HUP_PERCENT_LOAD, 64 SENSOR_PERCENT, "PercentLoad" }, 65 { HUP_BATTERY, HUB_CHARGING, 66 SENSOR_INDICATOR, "Charging" }, 67 { HUP_BATTERY, HUB_DISCHARGING, 68 SENSOR_INDICATOR, "Discharging" }, 69 { HUP_BATTERY, HUB_ATRATE_TIMETOFULL, 70 SENSOR_TIMEDELTA, "AtRateTimeToFull" }, 71 { HUP_BATTERY, HUB_ATRATE_TIMETOEMPTY, 72 SENSOR_TIMEDELTA, "AtRateTimeToEmpty" }, 73 { HUP_BATTERY, HUB_RUNTIMETO_EMPTY, 74 SENSOR_TIMEDELTA, "RunTimeToEmpty" }, 75 { HUP_BATTERY, HUB_NEED_REPLACEMENT, 76 SENSOR_INDICATOR, "NeedReplacement" }, 77 }; 78 static struct upd_usage_entry upd_usage_roots[] = { 79 { HUP_BATTERY, HUB_BATTERY_PRESENT, 80 SENSOR_INDICATOR, "BatteryPresent", 81 nitems(upd_usage_batdep), upd_usage_batdep }, 82 { HUP_POWER, HUP_SHUTDOWN_IMMINENT, 83 SENSOR_INDICATOR, "ShutdownImminent" }, 84 { HUP_BATTERY, HUB_AC_PRESENT, 85 SENSOR_INDICATOR, "ACPresent" }, 86 { HUP_POWER, HUP_OVERLOAD, 87 SENSOR_INDICATOR, "Overload" }, 88 }; 89 #define UPD_MAX_SENSORS (nitems(upd_usage_batdep) + nitems(upd_usage_roots)) 90 91 SLIST_HEAD(upd_sensor_head, upd_sensor); 92 93 struct upd_report { 94 size_t size; /* Size of the report */ 95 struct upd_sensor_head sensors; /* List in dependency order */ 96 int pending; /* Waiting for an answer */ 97 }; 98 99 struct upd_sensor { 100 struct ksensor ksensor; 101 struct hid_item hitem; 102 int attached; /* Is there a matching report */ 103 struct upd_sensor_head children; /* list of children sensors */ 104 SLIST_ENTRY(upd_sensor) dep_next; /* next in the child list */ 105 SLIST_ENTRY(upd_sensor) rep_next; /* next in the report list */ 106 }; 107 108 struct upd_softc { 109 struct uhidev sc_hdev; 110 int sc_num_sensors; 111 u_int sc_max_repid; 112 char sc_buf[256]; 113 114 /* sensor framework */ 115 struct ksensordev sc_sensordev; 116 struct sensor_task *sc_sensortask; 117 struct upd_report *sc_reports; 118 struct upd_sensor *sc_sensors; 119 struct upd_sensor_head sc_root_sensors; 120 }; 121 122 int upd_match(struct device *, void *, void *); 123 void upd_attach(struct device *, struct device *, void *); 124 void upd_attach_sensor_tree(struct upd_softc *, void *, int, int, 125 struct upd_usage_entry *, struct upd_sensor_head *); 126 int upd_detach(struct device *, int); 127 128 void upd_intr(struct uhidev *, void *, uint); 129 void upd_refresh(void *); 130 void upd_request_children(struct upd_softc *, struct upd_sensor_head *); 131 void upd_update_report_cb(void *, int, void *, int); 132 133 void upd_sensor_invalidate(struct upd_softc *, struct upd_sensor *); 134 void upd_sensor_update(struct upd_softc *, struct upd_sensor *, uint8_t *, int); 135 int upd_lookup_usage_entry(void *, int, struct upd_usage_entry *, 136 struct hid_item *); 137 struct upd_sensor *upd_lookup_sensor(struct upd_softc *, int, int); 138 139 struct cfdriver upd_cd = { 140 NULL, "upd", DV_DULL 141 }; 142 143 const struct cfattach upd_ca = { 144 sizeof(struct upd_softc), upd_match, upd_attach, upd_detach 145 }; 146 147 int 148 upd_match(struct device *parent, void *match, void *aux) 149 { 150 struct uhidev_attach_arg *uha = (struct uhidev_attach_arg *)aux; 151 int size; 152 void *desc; 153 struct hid_item item; 154 int ret = UMATCH_NONE; 155 int i; 156 157 if (!UHIDEV_CLAIM_MULTIPLE_REPORTID(uha)) 158 return (ret); 159 160 DPRINTF(("upd: vendor=0x%04x, product=0x%04x\n", uha->uaa->vendor, 161 uha->uaa->product)); 162 163 /* need at least one sensor from root of tree */ 164 uhidev_get_report_desc(uha->parent, &desc, &size); 165 for (i = 0; i < nitems(upd_usage_roots); i++) 166 if (upd_lookup_usage_entry(desc, size, 167 upd_usage_roots + i, &item)) { 168 ret = UMATCH_VENDOR_PRODUCT; 169 uha->claimed[item.report_ID] = 1; 170 } 171 172 return (ret); 173 } 174 175 void 176 upd_attach(struct device *parent, struct device *self, void *aux) 177 { 178 struct upd_softc *sc = (struct upd_softc *)self; 179 struct uhidev_attach_arg *uha = (struct uhidev_attach_arg *)aux; 180 int size; 181 int i; 182 void *desc; 183 184 sc->sc_hdev.sc_intr = upd_intr; 185 sc->sc_hdev.sc_parent = uha->parent; 186 SLIST_INIT(&sc->sc_root_sensors); 187 188 strlcpy(sc->sc_sensordev.xname, DEVNAME(sc), 189 sizeof(sc->sc_sensordev.xname)); 190 191 sc->sc_max_repid = uha->parent->sc_nrepid; 192 DPRINTF(("\nupd: devname=%s sc_max_repid=%d\n", 193 DEVNAME(sc), sc->sc_max_repid)); 194 195 sc->sc_reports = mallocarray(sc->sc_max_repid, 196 sizeof(struct upd_report), M_USBDEV, M_WAITOK | M_ZERO); 197 for (i = 0; i < sc->sc_max_repid; i++) 198 SLIST_INIT(&sc->sc_reports[i].sensors); 199 sc->sc_sensors = mallocarray(UPD_MAX_SENSORS, 200 sizeof(struct upd_sensor), M_USBDEV, M_WAITOK | M_ZERO); 201 for (i = 0; i < UPD_MAX_SENSORS; i++) 202 SLIST_INIT(&sc->sc_sensors[i].children); 203 204 sc->sc_num_sensors = 0; 205 uhidev_get_report_desc(uha->parent, &desc, &size); 206 upd_attach_sensor_tree(sc, desc, size, nitems(upd_usage_roots), 207 upd_usage_roots, &sc->sc_root_sensors); 208 DPRINTF(("upd: sc_num_sensors=%d\n", sc->sc_num_sensors)); 209 210 sc->sc_sensortask = sensor_task_register(sc, upd_refresh, 6); 211 if (sc->sc_sensortask == NULL) { 212 printf(", unable to register update task\n"); 213 return; 214 } 215 sensordev_install(&sc->sc_sensordev); 216 217 printf("\n"); 218 219 DPRINTF(("upd_attach: complete\n")); 220 } 221 222 void 223 upd_attach_sensor_tree(struct upd_softc *sc, void *desc, int size, 224 int nentries, struct upd_usage_entry *entries, 225 struct upd_sensor_head *queue) 226 { 227 struct hid_item item; 228 struct upd_usage_entry *entry; 229 struct upd_sensor *sensor; 230 struct upd_report *report; 231 int i; 232 233 for (i = 0; i < nentries; i++) { 234 entry = entries + i; 235 if (!upd_lookup_usage_entry(desc, size, entry, &item)) { 236 /* dependency missing, add children to parent */ 237 upd_attach_sensor_tree(sc, desc, size, 238 entry->nchildren, entry->children, queue); 239 continue; 240 } 241 242 DPRINTF(("%s: found %s on repid=%d\n", DEVNAME(sc), 243 entry->usage_name, item.report_ID)); 244 if (item.report_ID < 0 || 245 item.report_ID >= sc->sc_max_repid) 246 continue; 247 248 sensor = &sc->sc_sensors[sc->sc_num_sensors]; 249 memcpy(&sensor->hitem, &item, sizeof(struct hid_item)); 250 strlcpy(sensor->ksensor.desc, entry->usage_name, 251 sizeof(sensor->ksensor.desc)); 252 sensor->ksensor.type = entry->senstype; 253 sensor->ksensor.flags |= SENSOR_FINVALID; 254 sensor->ksensor.status = SENSOR_S_UNKNOWN; 255 sensor->ksensor.value = 0; 256 sensor_attach(&sc->sc_sensordev, &sensor->ksensor); 257 sensor->attached = 1; 258 SLIST_INSERT_HEAD(queue, sensor, dep_next); 259 sc->sc_num_sensors++; 260 261 upd_attach_sensor_tree(sc, desc, size, entry->nchildren, 262 entry->children, &sensor->children); 263 264 report = &sc->sc_reports[item.report_ID]; 265 if (SLIST_EMPTY(&report->sensors)) 266 report->size = hid_report_size(desc, 267 size, item.kind, item.report_ID); 268 SLIST_INSERT_HEAD(&report->sensors, sensor, rep_next); 269 } 270 } 271 272 int 273 upd_detach(struct device *self, int flags) 274 { 275 struct upd_softc *sc = (struct upd_softc *)self; 276 struct upd_sensor *sensor; 277 int i; 278 279 if (sc->sc_sensortask != NULL) 280 sensor_task_unregister(sc->sc_sensortask); 281 282 sensordev_deinstall(&sc->sc_sensordev); 283 284 for (i = 0; i < sc->sc_num_sensors; i++) { 285 sensor = &sc->sc_sensors[i]; 286 if (sensor->attached) 287 sensor_detach(&sc->sc_sensordev, &sensor->ksensor); 288 } 289 290 free(sc->sc_reports, M_USBDEV, sc->sc_max_repid * sizeof(struct upd_report)); 291 free(sc->sc_sensors, M_USBDEV, UPD_MAX_SENSORS * sizeof(struct upd_sensor)); 292 return (0); 293 } 294 295 void 296 upd_refresh(void *arg) 297 { 298 struct upd_softc *sc = arg; 299 int s; 300 301 /* request root sensors, do not let async handlers fire yet */ 302 s = splusb(); 303 upd_request_children(sc, &sc->sc_root_sensors); 304 splx(s); 305 } 306 307 void 308 upd_request_children(struct upd_softc *sc, struct upd_sensor_head *queue) 309 { 310 struct upd_sensor *sensor; 311 struct upd_report *report; 312 int len, repid; 313 314 SLIST_FOREACH(sensor, queue, dep_next) { 315 repid = sensor->hitem.report_ID; 316 report = &sc->sc_reports[repid]; 317 318 /* already requested */ 319 if (report->pending) 320 continue; 321 report->pending = 1; 322 323 len = uhidev_get_report_async(sc->sc_hdev.sc_parent, 324 UHID_FEATURE_REPORT, repid, sc->sc_buf, report->size, sc, 325 upd_update_report_cb); 326 327 /* request failed, force-invalidate all sensors in report */ 328 if (len < 0) { 329 upd_update_report_cb(sc, repid, NULL, -1); 330 report->pending = 0; 331 } 332 } 333 } 334 335 int 336 upd_lookup_usage_entry(void *desc, int size, struct upd_usage_entry *entry, 337 struct hid_item *item) 338 { 339 struct hid_data *hdata; 340 int ret = 0; 341 342 for (hdata = hid_start_parse(desc, size, hid_feature); 343 hid_get_item(hdata, item); ) { 344 if (item->kind == hid_feature && 345 entry->usage_pg == HID_GET_USAGE_PAGE(item->usage) && 346 entry->usage_id == HID_GET_USAGE(item->usage)) { 347 ret = 1; 348 break; 349 } 350 } 351 hid_end_parse(hdata); 352 353 return (ret); 354 } 355 356 struct upd_sensor * 357 upd_lookup_sensor(struct upd_softc *sc, int page, int usage) 358 { 359 struct upd_sensor *sensor = NULL; 360 int i; 361 362 for (i = 0; i < sc->sc_num_sensors; i++) { 363 sensor = &sc->sc_sensors[i]; 364 if (page == HID_GET_USAGE_PAGE(sensor->hitem.usage) && 365 usage == HID_GET_USAGE(sensor->hitem.usage)) 366 return (sensor); 367 } 368 return (NULL); 369 } 370 371 void 372 upd_update_report_cb(void *priv, int repid, void *data, int len) 373 { 374 struct upd_softc *sc = priv; 375 struct upd_report *report = &sc->sc_reports[repid]; 376 struct upd_sensor *sensor; 377 378 /* handle buggy firmware */ 379 if (len > 0 && report->size != len) 380 report->size = len; 381 382 if (data == NULL || len <= 0) { 383 SLIST_FOREACH(sensor, &report->sensors, rep_next) 384 upd_sensor_invalidate(sc, sensor); 385 } else { 386 SLIST_FOREACH(sensor, &report->sensors, rep_next) 387 upd_sensor_update(sc, sensor, data, len); 388 } 389 report->pending = 0; 390 } 391 392 void 393 upd_sensor_invalidate(struct upd_softc *sc, struct upd_sensor *sensor) 394 { 395 struct upd_sensor *child; 396 397 sensor->ksensor.status = SENSOR_S_UNKNOWN; 398 sensor->ksensor.flags |= SENSOR_FINVALID; 399 400 SLIST_FOREACH(child, &sensor->children, dep_next) 401 upd_sensor_invalidate(sc, child); 402 } 403 404 void 405 upd_sensor_update(struct upd_softc *sc, struct upd_sensor *sensor, 406 uint8_t *buf, int len) 407 { 408 struct upd_sensor *child; 409 int64_t hdata, adjust; 410 411 switch (HID_GET_USAGE(sensor->hitem.usage)) { 412 case HUB_REL_STATEOF_CHARGE: 413 case HUB_ABS_STATEOF_CHARGE: 414 case HUB_REM_CAPACITY: 415 case HUB_FULLCHARGE_CAPACITY: 416 case HUP_PERCENT_LOAD: 417 adjust = 1000; /* scale adjust */ 418 break; 419 case HUB_ATRATE_TIMETOFULL: 420 case HUB_ATRATE_TIMETOEMPTY: 421 case HUB_RUNTIMETO_EMPTY: 422 /* spec says minutes, not seconds */ 423 adjust = 1000000000LL; 424 break; 425 default: 426 adjust = 1; /* no scale adjust */ 427 break; 428 } 429 430 hdata = hid_get_data(buf, len, &sensor->hitem.loc); 431 if (sensor->ksensor.type == SENSOR_INDICATOR) 432 sensor->ksensor.value = hdata ? 1 : 0; 433 else 434 sensor->ksensor.value = hdata * adjust; 435 sensor->ksensor.status = SENSOR_S_OK; 436 sensor->ksensor.flags &= ~SENSOR_FINVALID; 437 438 /* if battery not present, invalidate children */ 439 if (HID_GET_USAGE_PAGE(sensor->hitem.usage) == HUP_BATTERY && 440 HID_GET_USAGE(sensor->hitem.usage) == HUB_BATTERY_PRESENT && 441 sensor->ksensor.value == 0) { 442 SLIST_FOREACH(child, &sensor->children, dep_next) 443 upd_sensor_invalidate(sc, child); 444 return; 445 } 446 447 upd_request_children(sc, &sensor->children); 448 } 449 450 void 451 upd_intr(struct uhidev *uh, void *p, uint len) 452 { 453 /* noop */ 454 } 455