1 /*- 2 * Copyright (c) 2018-2019 Marc Priggemeyer <marc.priggemeyer@gmail.com> 3 * Copyright (c) 2019-2020 Vladimir Kondratyev <wulf@FreeBSD.org> 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 */ 26 27 /* 28 * I2C HID transport backend. 29 */ 30 31 #include <sys/cdefs.h> 32 #include "opt_hid.h" 33 34 #include <sys/param.h> 35 #include <sys/bus.h> 36 #include <sys/callout.h> 37 #include <sys/endian.h> 38 #include <sys/kernel.h> 39 #include <sys/lock.h> 40 #include <sys/malloc.h> 41 #include <sys/module.h> 42 #include <sys/proc.h> 43 #include <sys/rman.h> 44 #include <sys/sysctl.h> 45 #include <sys/systm.h> 46 #include <sys/taskqueue.h> 47 48 #include <machine/resource.h> 49 50 #include <contrib/dev/acpica/include/acpi.h> 51 #include <contrib/dev/acpica/include/accommon.h> 52 #include <dev/acpica/acpivar.h> 53 54 #include <dev/evdev/input.h> 55 56 #include <dev/hid/hid.h> 57 #include <dev/hid/hidquirk.h> 58 59 #include <dev/iicbus/iic.h> 60 #include <dev/iicbus/iicbus.h> 61 #include <dev/iicbus/iiconf.h> 62 63 #include "hid_if.h" 64 65 #ifdef IICHID_DEBUG 66 static int iichid_debug = 0; 67 68 static SYSCTL_NODE(_hw, OID_AUTO, iichid, CTLFLAG_RW, 0, "I2C HID"); 69 SYSCTL_INT(_hw_iichid, OID_AUTO, debug, CTLFLAG_RWTUN, 70 &iichid_debug, 1, "Debug level"); 71 72 #define DPRINTFN(sc, n, ...) do { \ 73 if (iichid_debug >= (n)) \ 74 device_printf((sc)->dev, __VA_ARGS__); \ 75 } while (0) 76 #define DPRINTF(sc, ...) DPRINTFN(sc, 1, __VA_ARGS__) 77 #else 78 #define DPRINTFN(...) do {} while (0) 79 #define DPRINTF(...) do {} while (0) 80 #endif 81 82 typedef hid_size_t iichid_size_t; 83 #define IICHID_SIZE_MAX (UINT16_MAX - 2) 84 85 /* 7.2 */ 86 enum { 87 I2C_HID_CMD_DESCR = 0x0, 88 I2C_HID_CMD_RESET = 0x1, 89 I2C_HID_CMD_GET_REPORT = 0x2, 90 I2C_HID_CMD_SET_REPORT = 0x3, 91 I2C_HID_CMD_GET_IDLE = 0x4, 92 I2C_HID_CMD_SET_IDLE = 0x5, 93 I2C_HID_CMD_GET_PROTO = 0x6, 94 I2C_HID_CMD_SET_PROTO = 0x7, 95 I2C_HID_CMD_SET_POWER = 0x8, 96 }; 97 98 #define I2C_HID_POWER_ON 0x0 99 #define I2C_HID_POWER_OFF 0x1 100 101 #define IICHID_RESET_TIMEOUT 5 /* seconds */ 102 103 /* 104 * Since interrupt resource acquisition is not always possible (in case of GPIO 105 * interrupts) iichid now supports a sampling_mode. 106 * Set dev.iichid.<unit>.sampling_rate_slow to a value greater then 0 107 * to activate sampling. A value of 0 is possible but will not reset the 108 * callout and, thereby, disable further report requests. Do not set the 109 * sampling_rate_fast value too high as it may result in periodical lags of 110 * cursor motion. 111 */ 112 #define IICHID_SAMPLING_RATE_FAST 80 113 #define IICHID_SAMPLING_RATE_SLOW 10 114 #define IICHID_SAMPLING_HYSTERESIS 16 /* ~ 2x fast / slow */ 115 116 /* 5.1.1 - HID Descriptor Format */ 117 struct i2c_hid_desc { 118 uint16_t wHIDDescLength; 119 uint16_t bcdVersion; 120 uint16_t wReportDescLength; 121 uint16_t wReportDescRegister; 122 uint16_t wInputRegister; 123 uint16_t wMaxInputLength; 124 uint16_t wOutputRegister; 125 uint16_t wMaxOutputLength; 126 uint16_t wCommandRegister; 127 uint16_t wDataRegister; 128 uint16_t wVendorID; 129 uint16_t wProductID; 130 uint16_t wVersionID; 131 uint32_t reserved; 132 } __packed; 133 134 #define IICHID_REG_NONE -1 135 #define IICHID_REG_ACPI (UINT16_MAX + 1) 136 #define IICHID_REG_ELAN 0x0001 137 138 static const struct iichid_id { 139 char *id; 140 int reg; 141 } iichid_ids[] = { 142 { "ELAN0000", IICHID_REG_ELAN }, 143 { "PNP0C50", IICHID_REG_ACPI }, 144 { "ACPI0C50", IICHID_REG_ACPI }, 145 { NULL, 0 }, 146 }; 147 148 enum iichid_powerstate_how { 149 IICHID_PS_NULL, 150 IICHID_PS_ON, 151 IICHID_PS_OFF, 152 }; 153 154 /* 155 * Locking: no internal locks are used. To serialize access to shared members, 156 * external iicbus lock should be taken. That allows to make locking greatly 157 * simple at the cost of running front interrupt handlers with locked bus. 158 */ 159 struct iichid_softc { 160 device_t dev; 161 struct mtx mtx; 162 163 bool probe_done; 164 int probe_result; 165 166 struct hid_device_info hw; 167 uint16_t addr; /* Shifted left by 1 */ 168 struct i2c_hid_desc desc; 169 170 hid_intr_t *intr_handler; 171 void *intr_ctx; 172 uint8_t *intr_buf; 173 iichid_size_t intr_bufsize; 174 175 int irq_rid; 176 struct resource *irq_res; 177 void *irq_cookie; 178 179 #ifdef IICHID_SAMPLING 180 int sampling_rate_slow; /* iicbus lock */ 181 int sampling_rate_fast; 182 int sampling_hysteresis; 183 int missing_samples; /* iicbus lock */ 184 int dup_samples; /* iicbus lock */ 185 iichid_size_t dup_size; /* iicbus lock */ 186 bool callout_setup; /* iicbus lock */ 187 uint8_t *dup_buf; 188 struct taskqueue *taskqueue; 189 struct timeout_task sampling_task; /* iicbus lock */ 190 #endif 191 192 struct task suspend_task; 193 bool open; /* iicbus lock */ 194 bool suspend; /* iicbus lock */ 195 bool power_on; /* iicbus lock */ 196 bool reset_acked; /* iichid mtx */ 197 }; 198 199 static device_probe_t iichid_probe; 200 static device_attach_t iichid_attach; 201 static device_detach_t iichid_detach; 202 static device_resume_t iichid_resume; 203 static device_suspend_t iichid_suspend; 204 205 static void iichid_suspend_task(void *, int); 206 207 #ifdef IICHID_SAMPLING 208 static int iichid_setup_callout(struct iichid_softc *); 209 static int iichid_reset_callout(struct iichid_softc *); 210 static void iichid_teardown_callout(struct iichid_softc *); 211 #endif 212 213 static inline int 214 acpi_is_iichid(ACPI_HANDLE handle) 215 { 216 const struct iichid_id *ids; 217 UINT32 sta; 218 int reg; 219 220 for (ids = iichid_ids; ids->id != NULL; ids++) { 221 if (acpi_MatchHid(handle, ids->id)) { 222 reg = ids->reg; 223 break; 224 } 225 } 226 if (ids->id == NULL) 227 return (IICHID_REG_NONE); 228 229 /* 230 * If no _STA method or if it failed, then assume that 231 * the device is present. 232 */ 233 if (ACPI_FAILURE(acpi_GetInteger(handle, "_STA", &sta)) || 234 ACPI_DEVICE_PRESENT(sta)) 235 return (reg); 236 237 return (IICHID_REG_NONE); 238 } 239 240 static ACPI_STATUS 241 iichid_get_config_reg(ACPI_HANDLE handle, uint16_t *config_reg) 242 { 243 ACPI_OBJECT *result; 244 ACPI_BUFFER acpi_buf; 245 ACPI_STATUS status; 246 247 /* 248 * function (_DSM) to be evaluated to retrieve the address of 249 * the configuration register of the HID device. 250 */ 251 /* 3cdff6f7-4267-4555-ad05-b30a3d8938de */ 252 static uint8_t dsm_guid[ACPI_UUID_LENGTH] = { 253 0xF7, 0xF6, 0xDF, 0x3C, 0x67, 0x42, 0x55, 0x45, 254 0xAD, 0x05, 0xB3, 0x0A, 0x3D, 0x89, 0x38, 0xDE, 255 }; 256 257 status = acpi_EvaluateDSMTyped(handle, dsm_guid, 1, 1, NULL, &acpi_buf, 258 ACPI_TYPE_INTEGER); 259 if (ACPI_FAILURE(status)) { 260 printf("%s: error evaluating _DSM\n", __func__); 261 return (status); 262 } 263 result = (ACPI_OBJECT *) acpi_buf.Pointer; 264 *config_reg = result->Integer.Value & 0xFFFF; 265 266 AcpiOsFree(result); 267 return (status); 268 } 269 270 static int 271 iichid_cmd_read(struct iichid_softc* sc, void *buf, iichid_size_t maxlen, 272 iichid_size_t *actual_len) 273 { 274 /* 275 * 6.1.3 - Retrieval of Input Reports 276 * DEVICE returns the length (2 Bytes) and the entire Input Report. 277 */ 278 uint8_t actbuf[2] = { 0, 0 }; 279 /* Read actual input report length. */ 280 struct iic_msg msgs[] = { 281 { sc->addr, IIC_M_RD | IIC_M_NOSTOP, sizeof(actbuf), actbuf }, 282 }; 283 uint16_t actlen; 284 int error; 285 286 error = iicbus_transfer(sc->dev, msgs, nitems(msgs)); 287 if (error != 0) 288 return (error); 289 290 actlen = actbuf[0] | actbuf[1] << 8; 291 #ifdef IICHID_SAMPLING 292 if ((actlen == 0 && sc->sampling_rate_slow < 0) || 293 (maxlen == 0 && sc->sampling_rate_slow >= 0)) { 294 #else 295 if (actlen == 0) { 296 #endif 297 /* Read and discard reset command response. */ 298 msgs[0] = (struct iic_msg) 299 { sc->addr, IIC_M_RD | IIC_M_NOSTART, 300 le16toh(sc->desc.wMaxInputLength) - 2, sc->intr_buf }; 301 actlen = 0; 302 if (!sc->reset_acked) { 303 mtx_lock(&sc->mtx); 304 sc->reset_acked = true; 305 wakeup(&sc->reset_acked); 306 mtx_unlock(&sc->mtx); 307 } 308 #ifdef IICHID_SAMPLING 309 } else if ((actlen <= 2 || actlen == 0xFFFF) && 310 sc->sampling_rate_slow >= 0) { 311 /* Read and discard 1 byte to send I2C STOP condition. */ 312 msgs[0] = (struct iic_msg) 313 { sc->addr, IIC_M_RD | IIC_M_NOSTART, 1, actbuf }; 314 actlen = 0; 315 #endif 316 } else { 317 actlen -= 2; 318 if (actlen > maxlen) { 319 DPRINTF(sc, "input report too big. requested=%d " 320 "received=%d\n", maxlen, actlen); 321 actlen = maxlen; 322 } 323 /* Read input report itself. */ 324 msgs[0] = (struct iic_msg) 325 { sc->addr, IIC_M_RD | IIC_M_NOSTART, actlen, buf }; 326 } 327 328 error = iicbus_transfer(sc->dev, msgs, 1); 329 if (error == 0 && actual_len != NULL) 330 *actual_len = actlen; 331 332 DPRINTFN(sc, 5, 333 "%*D - %*D\n", 2, actbuf, " ", msgs[0].len, msgs[0].buf, " "); 334 335 return (error); 336 } 337 338 static int 339 iichid_cmd_write(struct iichid_softc *sc, const void *buf, iichid_size_t len) 340 { 341 /* 6.2.3 - Sending Output Reports. */ 342 uint8_t *cmdreg = (uint8_t *)&sc->desc.wOutputRegister; 343 uint16_t replen = 2 + len; 344 uint8_t cmd[4] = { cmdreg[0], cmdreg[1], replen & 0xFF, replen >> 8 }; 345 struct iic_msg msgs[] = { 346 {sc->addr, IIC_M_WR | IIC_M_NOSTOP, sizeof(cmd), cmd}, 347 {sc->addr, IIC_M_WR | IIC_M_NOSTART, len, __DECONST(void *, buf)}, 348 }; 349 350 if (le16toh(sc->desc.wMaxOutputLength) == 0) 351 return (IIC_ENOTSUPP); 352 if (len < 2) 353 return (IIC_ENOTSUPP); 354 355 DPRINTF(sc, "HID command I2C_HID_CMD_WRITE (len %d): " 356 "%*D\n", len, len, buf, " "); 357 358 return (iicbus_transfer(sc->dev, msgs, nitems(msgs))); 359 } 360 361 static int 362 iichid_cmd_get_hid_desc(struct iichid_softc *sc, uint16_t config_reg, 363 struct i2c_hid_desc *hid_desc) 364 { 365 /* 366 * 5.2.2 - HID Descriptor Retrieval 367 * register is passed from the controller. 368 */ 369 uint16_t cmd = htole16(config_reg); 370 struct iic_msg msgs[] = { 371 { sc->addr, IIC_M_WR | IIC_M_NOSTOP, 2, (uint8_t *)&cmd }, 372 { sc->addr, IIC_M_RD, sizeof(*hid_desc), (uint8_t *)hid_desc }, 373 }; 374 int error; 375 376 DPRINTF(sc, "HID command I2C_HID_CMD_DESCR at 0x%x\n", config_reg); 377 378 error = iicbus_transfer(sc->dev, msgs, nitems(msgs)); 379 if (error != 0) 380 return (error); 381 382 DPRINTF(sc, "HID descriptor: %*D\n", 383 (int)sizeof(struct i2c_hid_desc), hid_desc, " "); 384 385 return (0); 386 } 387 388 static int 389 iichid_set_power(struct iichid_softc *sc, uint8_t param) 390 { 391 uint8_t *cmdreg = (uint8_t *)&sc->desc.wCommandRegister; 392 uint8_t cmd[] = { cmdreg[0], cmdreg[1], param, I2C_HID_CMD_SET_POWER }; 393 struct iic_msg msgs[] = { 394 { sc->addr, IIC_M_WR, sizeof(cmd), cmd }, 395 }; 396 397 DPRINTF(sc, "HID command I2C_HID_CMD_SET_POWER(%d)\n", param); 398 399 return (iicbus_transfer(sc->dev, msgs, nitems(msgs))); 400 } 401 402 static int 403 iichid_reset(struct iichid_softc *sc) 404 { 405 uint8_t *cmdreg = (uint8_t *)&sc->desc.wCommandRegister; 406 uint8_t cmd[] = { cmdreg[0], cmdreg[1], 0, I2C_HID_CMD_RESET }; 407 struct iic_msg msgs[] = { 408 { sc->addr, IIC_M_WR, sizeof(cmd), cmd }, 409 }; 410 411 DPRINTF(sc, "HID command I2C_HID_CMD_RESET\n"); 412 413 return (iicbus_transfer(sc->dev, msgs, nitems(msgs))); 414 } 415 416 static int 417 iichid_cmd_get_report_desc(struct iichid_softc* sc, void *buf, 418 iichid_size_t len) 419 { 420 uint16_t cmd = sc->desc.wReportDescRegister; 421 struct iic_msg msgs[] = { 422 { sc->addr, IIC_M_WR | IIC_M_NOSTOP, 2, (uint8_t *)&cmd }, 423 { sc->addr, IIC_M_RD, len, buf }, 424 }; 425 int error; 426 427 DPRINTF(sc, "HID command I2C_HID_REPORT_DESCR at 0x%x with size %d\n", 428 le16toh(cmd), len); 429 430 error = iicbus_transfer(sc->dev, msgs, nitems(msgs)); 431 if (error != 0) 432 return (error); 433 434 DPRINTF(sc, "HID report descriptor: %*D\n", len, buf, " "); 435 436 return (0); 437 } 438 439 static int 440 iichid_cmd_get_report(struct iichid_softc* sc, void *buf, iichid_size_t maxlen, 441 iichid_size_t *actual_len, uint8_t type, uint8_t id) 442 { 443 /* 444 * 7.2.2.4 - "The protocol is optimized for Report < 15. If a 445 * report ID >= 15 is necessary, then the Report ID in the Low Byte 446 * must be set to 1111 and a Third Byte is appended to the protocol. 447 * This Third Byte contains the entire/actual report ID." 448 */ 449 uint8_t *dtareg = (uint8_t *)&sc->desc.wDataRegister; 450 uint8_t *cmdreg = (uint8_t *)&sc->desc.wCommandRegister; 451 uint8_t cmd[] = { /*________|______id>=15_____|______id<15______*/ 452 cmdreg[0] , 453 cmdreg[1] , 454 (id >= 15 ? 15 | (type << 4): id | (type << 4)), 455 I2C_HID_CMD_GET_REPORT , 456 (id >= 15 ? id : dtareg[0] ), 457 (id >= 15 ? dtareg[0] : dtareg[1] ), 458 (id >= 15 ? dtareg[1] : 0 ), 459 }; 460 int cmdlen = (id >= 15 ? 7 : 6 ); 461 uint8_t actbuf[2] = { 0, 0 }; 462 uint16_t actlen; 463 int d, error; 464 struct iic_msg msgs[] = { 465 { sc->addr, IIC_M_WR | IIC_M_NOSTOP, cmdlen, cmd }, 466 { sc->addr, IIC_M_RD | IIC_M_NOSTOP, 2, actbuf }, 467 { sc->addr, IIC_M_RD | IIC_M_NOSTART, maxlen, buf }, 468 }; 469 470 if (maxlen == 0) 471 return (EINVAL); 472 473 DPRINTF(sc, "HID command I2C_HID_CMD_GET_REPORT %d " 474 "(type %d, len %d)\n", id, type, maxlen); 475 476 /* 477 * 7.2.2.2 - Response will be a 2-byte length value, the report 478 * id (1 byte, if defined in Report Descriptor), and then the report. 479 */ 480 error = iicbus_transfer(sc->dev, msgs, nitems(msgs)); 481 if (error != 0) 482 return (error); 483 484 actlen = actbuf[0] | actbuf[1] << 8; 485 if (actlen != maxlen + 2) 486 DPRINTF(sc, "response size %d != expected length %d\n", 487 actlen, maxlen + 2); 488 489 if (actlen <= 2 || actlen == 0xFFFF) 490 return (ENOMSG); 491 492 d = id != 0 ? *(uint8_t *)buf : 0; 493 if (d != id) { 494 DPRINTF(sc, "response report id %d != %d\n", d, id); 495 return (EBADMSG); 496 } 497 498 actlen -= 2; 499 if (actlen > maxlen) 500 actlen = maxlen; 501 if (actual_len != NULL) 502 *actual_len = actlen; 503 504 DPRINTF(sc, "response: %*D %*D\n", 2, actbuf, " ", actlen, buf, " "); 505 506 return (0); 507 } 508 509 static int 510 iichid_cmd_set_report(struct iichid_softc* sc, const void *buf, 511 iichid_size_t len, uint8_t type, uint8_t id) 512 { 513 /* 514 * 7.2.2.4 - "The protocol is optimized for Report < 15. If a 515 * report ID >= 15 is necessary, then the Report ID in the Low Byte 516 * must be set to 1111 and a Third Byte is appended to the protocol. 517 * This Third Byte contains the entire/actual report ID." 518 */ 519 uint8_t *dtareg = (uint8_t *)&sc->desc.wDataRegister; 520 uint8_t *cmdreg = (uint8_t *)&sc->desc.wCommandRegister; 521 uint16_t replen = 2 + len; 522 uint8_t cmd[] = { /*________|______id>=15_____|______id<15______*/ 523 cmdreg[0] , 524 cmdreg[1] , 525 (id >= 15 ? 15 | (type << 4): id | (type << 4)), 526 I2C_HID_CMD_SET_REPORT , 527 (id >= 15 ? id : dtareg[0] ), 528 (id >= 15 ? dtareg[0] : dtareg[1] ), 529 (id >= 15 ? dtareg[1] : replen & 0xff ), 530 (id >= 15 ? replen & 0xff : replen >> 8 ), 531 (id >= 15 ? replen >> 8 : 0 ), 532 }; 533 int cmdlen = (id >= 15 ? 9 : 8 ); 534 struct iic_msg msgs[] = { 535 {sc->addr, IIC_M_WR | IIC_M_NOSTOP, cmdlen, cmd}, 536 {sc->addr, IIC_M_WR | IIC_M_NOSTART, len, __DECONST(void *, buf)}, 537 }; 538 539 DPRINTF(sc, "HID command I2C_HID_CMD_SET_REPORT %d (type %d, len %d): " 540 "%*D\n", id, type, len, len, buf, " "); 541 542 return (iicbus_transfer(sc->dev, msgs, nitems(msgs))); 543 } 544 545 #ifdef IICHID_SAMPLING 546 static void 547 iichid_sampling_task(void *context, int pending) 548 { 549 struct iichid_softc *sc; 550 device_t parent; 551 iichid_size_t actual; 552 bool bus_requested; 553 int error, rate; 554 555 sc = context; 556 parent = device_get_parent(sc->dev); 557 558 bus_requested = false; 559 if (iicbus_request_bus(parent, sc->dev, IIC_WAIT) != 0) 560 goto rearm; 561 bus_requested = true; 562 563 if (!sc->power_on) 564 goto out; 565 566 error = iichid_cmd_read(sc, sc->intr_buf, sc->intr_bufsize, &actual); 567 if (error == 0) { 568 if (actual > 0) { 569 sc->intr_handler(sc->intr_ctx, sc->intr_buf, actual); 570 sc->missing_samples = 0; 571 if (sc->dup_size != actual || 572 memcmp(sc->dup_buf, sc->intr_buf, actual) != 0) { 573 sc->dup_size = actual; 574 memcpy(sc->dup_buf, sc->intr_buf, actual); 575 sc->dup_samples = 0; 576 } else 577 ++sc->dup_samples; 578 } else { 579 if (++sc->missing_samples == 1) 580 sc->intr_handler(sc->intr_ctx, sc->intr_buf, 0); 581 sc->dup_samples = 0; 582 } 583 } else 584 DPRINTF(sc, "read error occurred: %d\n", error); 585 586 rearm: 587 if (sc->callout_setup && sc->sampling_rate_slow > 0) { 588 if (sc->missing_samples >= sc->sampling_hysteresis || 589 sc->dup_samples >= sc->sampling_hysteresis) 590 rate = sc->sampling_rate_slow; 591 else 592 rate = sc->sampling_rate_fast; 593 taskqueue_enqueue_timeout_sbt(sc->taskqueue, &sc->sampling_task, 594 SBT_1S / MAX(rate, 1), 0, C_PREL(2)); 595 } 596 out: 597 if (bus_requested) 598 iicbus_release_bus(parent, sc->dev); 599 } 600 #endif /* IICHID_SAMPLING */ 601 602 static void 603 iichid_intr(void *context) 604 { 605 struct iichid_softc *sc; 606 device_t parent; 607 iichid_size_t actual; 608 int error; 609 610 sc = context; 611 parent = device_get_parent(sc->dev); 612 613 /* 614 * Designware(IG4) driver-specific hack. 615 * Requesting of an I2C bus with IIC_DONTWAIT parameter enables polled 616 * mode in the driver, making possible iicbus_transfer execution from 617 * interrupt handlers and callouts. 618 */ 619 if (iicbus_request_bus(parent, sc->dev, IIC_DONTWAIT) != 0) 620 return; 621 622 /* 623 * Reading of input reports of I2C devices residing in SLEEP state is 624 * not allowed and often returns a garbage. If a HOST needs to 625 * communicate with the DEVICE it MUST issue a SET POWER command 626 * (to ON) before any other command. As some hardware requires reads to 627 * acknowledge interrupts we fetch only length header and discard it. 628 */ 629 THREAD_SLEEPING_OK(); 630 error = iichid_cmd_read(sc, sc->intr_buf, sc->intr_bufsize, &actual); 631 THREAD_NO_SLEEPING(); 632 if (error == 0) { 633 if (sc->power_on) { 634 if (actual != 0) 635 sc->intr_handler(sc->intr_ctx, sc->intr_buf, 636 actual); 637 else 638 DPRINTF(sc, "no data received\n"); 639 } 640 } else 641 DPRINTF(sc, "read error occurred: %d\n", error); 642 643 iicbus_release_bus(parent, sc->dev); 644 } 645 646 static int 647 iichid_set_power_state(struct iichid_softc *sc, 648 enum iichid_powerstate_how how_open, 649 enum iichid_powerstate_how how_suspend) 650 { 651 device_t parent; 652 int error; 653 int how_request; 654 bool power_on; 655 656 /* 657 * Request iicbus early as sc->suspend and sc->power_on 658 * are protected by iicbus internal lock. 659 */ 660 parent = device_get_parent(sc->dev); 661 /* Allow to interrupt open()/close() handlers by SIGINT */ 662 how_request = how_open == IICHID_PS_NULL ? IIC_WAIT : IIC_INTRWAIT; 663 error = iicbus_request_bus(parent, sc->dev, how_request); 664 if (error != 0) 665 return (error); 666 667 switch (how_open) { 668 case IICHID_PS_ON: 669 sc->open = true; 670 break; 671 case IICHID_PS_OFF: 672 sc->open = false; 673 break; 674 case IICHID_PS_NULL: 675 default: 676 break; 677 } 678 679 switch (how_suspend) { 680 case IICHID_PS_ON: 681 sc->suspend = false; 682 break; 683 case IICHID_PS_OFF: 684 sc->suspend = true; 685 break; 686 case IICHID_PS_NULL: 687 default: 688 break; 689 } 690 691 power_on = sc->open & !sc->suspend; 692 693 if (power_on != sc->power_on) { 694 error = iichid_set_power(sc, 695 power_on ? I2C_HID_POWER_ON : I2C_HID_POWER_OFF); 696 697 sc->power_on = power_on; 698 #ifdef IICHID_SAMPLING 699 if (sc->sampling_rate_slow >= 0 && sc->intr_handler != NULL) { 700 if (power_on) { 701 iichid_setup_callout(sc); 702 iichid_reset_callout(sc); 703 } else 704 iichid_teardown_callout(sc); 705 } 706 #endif 707 } 708 709 iicbus_release_bus(parent, sc->dev); 710 711 return (error); 712 } 713 714 static int 715 iichid_setup_interrupt(struct iichid_softc *sc) 716 { 717 sc->irq_cookie = 0; 718 719 int error = bus_setup_intr(sc->dev, sc->irq_res, 720 INTR_TYPE_TTY|INTR_MPSAFE, NULL, iichid_intr, sc, &sc->irq_cookie); 721 if (error != 0) 722 DPRINTF(sc, "Could not setup interrupt handler\n"); 723 else 724 DPRINTF(sc, "successfully setup interrupt\n"); 725 726 return (error); 727 } 728 729 static void 730 iichid_teardown_interrupt(struct iichid_softc *sc) 731 { 732 if (sc->irq_cookie) 733 bus_teardown_intr(sc->dev, sc->irq_res, sc->irq_cookie); 734 735 sc->irq_cookie = 0; 736 } 737 738 #ifdef IICHID_SAMPLING 739 static int 740 iichid_setup_callout(struct iichid_softc *sc) 741 { 742 743 if (sc->sampling_rate_slow < 0) { 744 DPRINTF(sc, "sampling_rate is below 0, can't setup callout\n"); 745 return (EINVAL); 746 } 747 748 sc->callout_setup = true; 749 DPRINTF(sc, "successfully setup callout\n"); 750 return (0); 751 } 752 753 static int 754 iichid_reset_callout(struct iichid_softc *sc) 755 { 756 757 if (sc->sampling_rate_slow <= 0) { 758 DPRINTF(sc, "sampling_rate is below or equal to 0, " 759 "can't reset callout\n"); 760 return (EINVAL); 761 } 762 763 if (!sc->callout_setup) 764 return (EINVAL); 765 766 /* Start with slow sampling. */ 767 sc->missing_samples = sc->sampling_hysteresis; 768 sc->dup_samples = 0; 769 sc->dup_size = 0; 770 taskqueue_enqueue_timeout(sc->taskqueue, &sc->sampling_task, 0); 771 772 return (0); 773 } 774 775 static void 776 iichid_teardown_callout(struct iichid_softc *sc) 777 { 778 779 sc->callout_setup = false; 780 taskqueue_cancel_timeout(sc->taskqueue, &sc->sampling_task, NULL); 781 DPRINTF(sc, "tore callout down\n"); 782 } 783 784 static int 785 iichid_sysctl_sampling_rate_handler(SYSCTL_HANDLER_ARGS) 786 { 787 struct iichid_softc *sc; 788 device_t parent; 789 int error, oldval, value; 790 791 sc = arg1; 792 793 value = sc->sampling_rate_slow; 794 error = sysctl_handle_int(oidp, &value, 0, req); 795 796 if (error != 0 || req->newptr == NULL || 797 value == sc->sampling_rate_slow) 798 return (error); 799 800 /* Can't switch to interrupt mode if it is not supported. */ 801 if (sc->irq_res == NULL && value < 0) 802 return (EINVAL); 803 804 parent = device_get_parent(sc->dev); 805 error = iicbus_request_bus(parent, sc->dev, IIC_WAIT); 806 if (error != 0) 807 return (iic2errno(error)); 808 809 oldval = sc->sampling_rate_slow; 810 sc->sampling_rate_slow = value; 811 812 if (oldval < 0 && value >= 0) { 813 iichid_teardown_interrupt(sc); 814 if (sc->power_on) 815 iichid_setup_callout(sc); 816 } else if (oldval >= 0 && value < 0) { 817 if (sc->power_on) 818 iichid_teardown_callout(sc); 819 iichid_setup_interrupt(sc); 820 } 821 822 if (sc->power_on && value > 0) 823 iichid_reset_callout(sc); 824 825 iicbus_release_bus(parent, sc->dev); 826 827 DPRINTF(sc, "new sampling_rate value: %d\n", value); 828 829 return (0); 830 } 831 #endif /* IICHID_SAMPLING */ 832 833 static void 834 iichid_intr_setup(device_t dev, device_t child __unused, hid_intr_t intr, 835 void *context, struct hid_rdesc_info *rdesc) 836 { 837 struct iichid_softc *sc; 838 device_t parent; 839 840 if (intr == NULL) 841 return; 842 843 sc = device_get_softc(dev); 844 /* 845 * Do not rely on wMaxInputLength, as some devices may set it to 846 * a wrong length. Find the longest input report in report descriptor. 847 */ 848 rdesc->rdsize = 849 MAX(rdesc->isize, le16toh(sc->desc.wMaxInputLength) - 2); 850 /* Write and get/set_report sizes are limited by I2C-HID protocol. */ 851 rdesc->grsize = rdesc->srsize = IICHID_SIZE_MAX; 852 rdesc->wrsize = IICHID_SIZE_MAX; 853 854 parent = device_get_parent(sc->dev); 855 iicbus_request_bus(parent, sc->dev, IIC_WAIT); 856 857 sc->intr_handler = intr; 858 sc->intr_ctx = context; 859 sc->intr_bufsize = rdesc->rdsize; 860 sc->intr_buf = realloc(sc->intr_buf, sc->intr_bufsize, 861 M_DEVBUF, M_WAITOK | M_ZERO); 862 #ifdef IICHID_SAMPLING 863 sc->dup_buf = realloc(sc->dup_buf, sc->intr_bufsize, 864 M_DEVBUF, M_WAITOK | M_ZERO); 865 taskqueue_start_threads(&sc->taskqueue, 1, PI_TTY, 866 "%s taskq", device_get_nameunit(sc->dev)); 867 #endif 868 iicbus_release_bus(parent, sc->dev); 869 } 870 871 static void 872 iichid_intr_unsetup(device_t dev, device_t child __unused) 873 { 874 #ifdef IICHID_SAMPLING 875 struct iichid_softc *sc; 876 877 sc = device_get_softc(dev); 878 taskqueue_drain_all(sc->taskqueue); 879 #endif 880 } 881 882 static int 883 iichid_intr_start(device_t dev, device_t child __unused) 884 { 885 struct iichid_softc *sc; 886 887 sc = device_get_softc(dev); 888 DPRINTF(sc, "iichid device open\n"); 889 iichid_set_power_state(sc, IICHID_PS_ON, IICHID_PS_NULL); 890 891 return (0); 892 } 893 894 static int 895 iichid_intr_stop(device_t dev, device_t child __unused) 896 { 897 struct iichid_softc *sc; 898 899 sc = device_get_softc(dev); 900 DPRINTF(sc, "iichid device close\n"); 901 /* 902 * 8.2 - The HOST determines that there are no active applications 903 * that are currently using the specific HID DEVICE. The HOST 904 * is recommended to issue a HIPO command to the DEVICE to force 905 * the DEVICE in to a lower power state. 906 */ 907 iichid_set_power_state(sc, IICHID_PS_OFF, IICHID_PS_NULL); 908 909 return (0); 910 } 911 912 static void 913 iichid_intr_poll(device_t dev, device_t child __unused) 914 { 915 struct iichid_softc *sc; 916 iichid_size_t actual; 917 int error; 918 919 sc = device_get_softc(dev); 920 error = iichid_cmd_read(sc, sc->intr_buf, sc->intr_bufsize, &actual); 921 if (error == 0 && actual != 0) 922 sc->intr_handler(sc->intr_ctx, sc->intr_buf, actual); 923 } 924 925 /* 926 * HID interface 927 */ 928 static int 929 iichid_get_rdesc(device_t dev, device_t child __unused, void *buf, 930 hid_size_t len) 931 { 932 struct iichid_softc *sc; 933 int error; 934 935 sc = device_get_softc(dev); 936 error = iichid_cmd_get_report_desc(sc, buf, len); 937 if (error) 938 DPRINTF(sc, "failed to fetch report descriptor: %d\n", error); 939 940 return (iic2errno(error)); 941 } 942 943 static int 944 iichid_read(device_t dev, device_t child __unused, void *buf, 945 hid_size_t maxlen, hid_size_t *actlen) 946 { 947 struct iichid_softc *sc; 948 device_t parent; 949 int error; 950 951 if (maxlen > IICHID_SIZE_MAX) 952 return (EMSGSIZE); 953 sc = device_get_softc(dev); 954 parent = device_get_parent(sc->dev); 955 error = iicbus_request_bus(parent, sc->dev, IIC_WAIT); 956 if (error == 0) { 957 error = iichid_cmd_read(sc, buf, maxlen, actlen); 958 iicbus_release_bus(parent, sc->dev); 959 } 960 return (iic2errno(error)); 961 } 962 963 static int 964 iichid_write(device_t dev, device_t child __unused, const void *buf, 965 hid_size_t len) 966 { 967 struct iichid_softc *sc; 968 969 if (len > IICHID_SIZE_MAX) 970 return (EMSGSIZE); 971 sc = device_get_softc(dev); 972 return (iic2errno(iichid_cmd_write(sc, buf, len))); 973 } 974 975 static int 976 iichid_get_report(device_t dev, device_t child __unused, void *buf, 977 hid_size_t maxlen, hid_size_t *actlen, uint8_t type, uint8_t id) 978 { 979 struct iichid_softc *sc; 980 981 if (maxlen > IICHID_SIZE_MAX) 982 return (EMSGSIZE); 983 sc = device_get_softc(dev); 984 return (iic2errno( 985 iichid_cmd_get_report(sc, buf, maxlen, actlen, type, id))); 986 } 987 988 static int 989 iichid_set_report(device_t dev, device_t child __unused, const void *buf, 990 hid_size_t len, uint8_t type, uint8_t id) 991 { 992 struct iichid_softc *sc; 993 994 if (len > IICHID_SIZE_MAX) 995 return (EMSGSIZE); 996 sc = device_get_softc(dev); 997 return (iic2errno(iichid_cmd_set_report(sc, buf, len, type, id))); 998 } 999 1000 static int 1001 iichid_set_idle(device_t dev, device_t child __unused, 1002 uint16_t duration, uint8_t id) 1003 { 1004 return (ENOTSUP); 1005 } 1006 1007 static int 1008 iichid_set_protocol(device_t dev, device_t child __unused, uint16_t protocol) 1009 { 1010 return (ENOTSUP); 1011 } 1012 1013 static int 1014 iichid_ioctl(device_t dev, device_t child __unused, unsigned long cmd, 1015 uintptr_t data) 1016 { 1017 int error; 1018 1019 switch (cmd) { 1020 case I2CRDWR: 1021 error = iic2errno(iicbus_transfer(dev, 1022 ((struct iic_rdwr_data *)data)->msgs, 1023 ((struct iic_rdwr_data *)data)->nmsgs)); 1024 break; 1025 default: 1026 error = EINVAL; 1027 } 1028 1029 return (error); 1030 } 1031 1032 static int 1033 iichid_fill_device_info(struct i2c_hid_desc *desc, ACPI_HANDLE handle, 1034 struct hid_device_info *hw) 1035 { 1036 ACPI_DEVICE_INFO *device_info; 1037 1038 hw->idBus = BUS_I2C; 1039 hw->idVendor = le16toh(desc->wVendorID); 1040 hw->idProduct = le16toh(desc->wProductID); 1041 hw->idVersion = le16toh(desc->wVersionID); 1042 1043 /* get ACPI HID. It is a base part of the device name. */ 1044 if (ACPI_FAILURE(AcpiGetObjectInfo(handle, &device_info))) 1045 return (ENXIO); 1046 1047 if (device_info->Valid & ACPI_VALID_HID) 1048 strlcpy(hw->idPnP, device_info->HardwareId.String, 1049 HID_PNP_ID_SIZE); 1050 snprintf(hw->name, sizeof(hw->name), "%s:%02lX %04X:%04X", 1051 (device_info->Valid & ACPI_VALID_HID) ? 1052 device_info->HardwareId.String : "Unknown", 1053 (device_info->Valid & ACPI_VALID_UID) ? 1054 strtoul(device_info->UniqueId.String, NULL, 10) : 0UL, 1055 le16toh(desc->wVendorID), le16toh(desc->wProductID)); 1056 1057 AcpiOsFree(device_info); 1058 1059 strlcpy(hw->serial, "", sizeof(hw->serial)); 1060 hw->rdescsize = le16toh(desc->wReportDescLength); 1061 if (desc->wOutputRegister == 0 || desc->wMaxOutputLength == 0) 1062 hid_add_dynamic_quirk(hw, HQ_NOWRITE); 1063 1064 return (0); 1065 } 1066 1067 static int 1068 iichid_probe(device_t dev) 1069 { 1070 struct iichid_softc *sc; 1071 ACPI_HANDLE handle; 1072 uint16_t config_reg; 1073 int error, reg; 1074 1075 sc = device_get_softc(dev); 1076 sc->dev = dev; 1077 if (sc->probe_done) 1078 goto done; 1079 1080 sc->probe_done = true; 1081 sc->probe_result = ENXIO; 1082 1083 if (acpi_disabled("iichid")) 1084 return (ENXIO); 1085 1086 sc->addr = iicbus_get_addr(dev) << 1; 1087 if (sc->addr == 0) 1088 return (ENXIO); 1089 1090 handle = acpi_get_handle(dev); 1091 if (handle == NULL) 1092 return (ENXIO); 1093 1094 reg = acpi_is_iichid(handle); 1095 if (reg == IICHID_REG_NONE) 1096 return (ENXIO); 1097 1098 if (reg == IICHID_REG_ACPI) { 1099 if (ACPI_FAILURE(iichid_get_config_reg(handle, &config_reg))) 1100 return (ENXIO); 1101 } else 1102 config_reg = (uint16_t)reg; 1103 1104 DPRINTF(sc, " IICbus addr : 0x%02X\n", sc->addr >> 1); 1105 DPRINTF(sc, " HID descriptor reg: 0x%02X\n", config_reg); 1106 1107 error = iichid_cmd_get_hid_desc(sc, config_reg, &sc->desc); 1108 if (error) { 1109 DPRINTF(sc, "could not retrieve HID descriptor from the " 1110 "device: %d\n", error); 1111 return (ENXIO); 1112 } 1113 1114 if (le16toh(sc->desc.wHIDDescLength) != 30 || 1115 le16toh(sc->desc.bcdVersion) != 0x100) { 1116 DPRINTF(sc, "HID descriptor is broken\n"); 1117 return (ENXIO); 1118 } 1119 1120 /* Setup hid_device_info so we can figure out quirks for the device. */ 1121 if (iichid_fill_device_info(&sc->desc, handle, &sc->hw) != 0) { 1122 DPRINTF(sc, "error evaluating AcpiGetObjectInfo\n"); 1123 return (ENXIO); 1124 } 1125 1126 if (hid_test_quirk(&sc->hw, HQ_HID_IGNORE)) 1127 return (ENXIO); 1128 1129 sc->probe_result = BUS_PROBE_DEFAULT; 1130 done: 1131 if (sc->probe_result <= BUS_PROBE_SPECIFIC) 1132 device_set_descf(dev, "%s I2C HID device", sc->hw.name); 1133 return (sc->probe_result); 1134 } 1135 1136 static int 1137 iichid_attach(device_t dev) 1138 { 1139 struct iichid_softc *sc; 1140 device_t child; 1141 int error; 1142 1143 sc = device_get_softc(dev); 1144 error = iichid_set_power(sc, I2C_HID_POWER_ON); 1145 if (error) { 1146 device_printf(dev, "failed to power on: %d\n", error); 1147 return (ENXIO); 1148 } 1149 sc->power_on = true; 1150 1151 mtx_init(&sc->mtx, device_get_nameunit(dev), NULL, MTX_DEF); 1152 sc->intr_bufsize = le16toh(sc->desc.wMaxInputLength) - 2; 1153 sc->intr_buf = malloc(sc->intr_bufsize, M_DEVBUF, M_WAITOK | M_ZERO); 1154 TASK_INIT(&sc->suspend_task, 0, iichid_suspend_task, sc); 1155 #ifdef IICHID_SAMPLING 1156 sc->taskqueue = taskqueue_create_fast("iichid_tq", M_WAITOK | M_ZERO, 1157 taskqueue_thread_enqueue, &sc->taskqueue); 1158 TIMEOUT_TASK_INIT(sc->taskqueue, &sc->sampling_task, 0, 1159 iichid_sampling_task, sc); 1160 1161 sc->sampling_rate_slow = -1; 1162 sc->sampling_rate_fast = IICHID_SAMPLING_RATE_FAST; 1163 sc->sampling_hysteresis = IICHID_SAMPLING_HYSTERESIS; 1164 sc->dup_buf = malloc(sc->intr_bufsize, M_DEVBUF, M_WAITOK | M_ZERO); 1165 #endif 1166 1167 sc->irq_rid = 0; 1168 sc->irq_res = bus_alloc_resource_any(sc->dev, SYS_RES_IRQ, 1169 &sc->irq_rid, RF_ACTIVE); 1170 1171 if (sc->irq_res != NULL) { 1172 DPRINTF(sc, "allocated irq at %p and rid %d\n", 1173 sc->irq_res, sc->irq_rid); 1174 error = iichid_setup_interrupt(sc); 1175 } 1176 1177 if (sc->irq_res == NULL || error != 0) { 1178 #ifdef IICHID_SAMPLING 1179 device_printf(sc->dev, 1180 "Using sampling mode\n"); 1181 sc->sampling_rate_slow = IICHID_SAMPLING_RATE_SLOW; 1182 #else 1183 device_printf(sc->dev, "Interrupt setup failed\n"); 1184 if (sc->irq_res != NULL) 1185 bus_release_resource(dev, SYS_RES_IRQ, sc->irq_rid, 1186 sc->irq_res); 1187 iichid_detach(dev); 1188 error = ENXIO; 1189 goto done; 1190 #endif 1191 } 1192 1193 #ifdef IICHID_SAMPLING 1194 SYSCTL_ADD_PROC(device_get_sysctl_ctx(sc->dev), 1195 SYSCTL_CHILDREN(device_get_sysctl_tree(sc->dev)), 1196 OID_AUTO, "sampling_rate_slow", CTLTYPE_INT | CTLFLAG_RWTUN, 1197 sc, 0, iichid_sysctl_sampling_rate_handler, "I", 1198 "idle sampling rate in num/second"); 1199 SYSCTL_ADD_INT(device_get_sysctl_ctx(sc->dev), 1200 SYSCTL_CHILDREN(device_get_sysctl_tree(sc->dev)), 1201 OID_AUTO, "sampling_rate_fast", CTLFLAG_RWTUN, 1202 &sc->sampling_rate_fast, 0, 1203 "active sampling rate in num/second"); 1204 SYSCTL_ADD_INT(device_get_sysctl_ctx(sc->dev), 1205 SYSCTL_CHILDREN(device_get_sysctl_tree(sc->dev)), 1206 OID_AUTO, "sampling_hysteresis", CTLFLAG_RWTUN, 1207 &sc->sampling_hysteresis, 0, 1208 "number of missing samples before enabling of slow mode"); 1209 hid_add_dynamic_quirk(&sc->hw, HQ_IICHID_SAMPLING); 1210 #endif /* IICHID_SAMPLING */ 1211 1212 /* 1213 * Windows driver sleeps for 1ms between the SET_POWER and RESET 1214 * commands. So we too as some devices may depend on this. 1215 */ 1216 pause("iichid", (hz + 999) / 1000); 1217 1218 error = iichid_reset(sc); 1219 if (error) { 1220 device_printf(dev, "failed to reset hardware: %d\n", error); 1221 iichid_detach(dev); 1222 error = ENXIO; 1223 goto done; 1224 } 1225 1226 /* Wait for RESET response */ 1227 #ifdef IICHID_SAMPLING 1228 if (sc->sampling_rate_slow >= 0) { 1229 pause("iichid", (hz + 999) / 1000); 1230 (void)iichid_cmd_read(sc, sc->intr_buf, 0, NULL); 1231 } else 1232 #endif /* IICHID_SAMPLING */ 1233 { 1234 mtx_lock(&sc->mtx); 1235 if (!sc->reset_acked && !cold) { 1236 error = mtx_sleep(&sc->reset_acked, &sc->mtx, 0, 1237 "iichid_reset", hz * IICHID_RESET_TIMEOUT); 1238 if (error != 0) 1239 device_printf(sc->dev, 1240 "Reset timeout expired\n"); 1241 } 1242 mtx_unlock(&sc->mtx); 1243 } 1244 1245 child = device_add_child(dev, "hidbus", DEVICE_UNIT_ANY); 1246 if (child == NULL) { 1247 device_printf(sc->dev, "Could not add I2C device\n"); 1248 iichid_detach(dev); 1249 error = ENOMEM; 1250 goto done; 1251 } 1252 1253 device_set_ivars(child, &sc->hw); 1254 bus_attach_children(dev); 1255 error = 0; 1256 done: 1257 iicbus_request_bus(device_get_parent(dev), dev, IIC_WAIT); 1258 if (!sc->open) { 1259 (void)iichid_set_power(sc, I2C_HID_POWER_OFF); 1260 sc->power_on = false; 1261 } 1262 iicbus_release_bus(device_get_parent(dev), dev); 1263 return (error); 1264 } 1265 1266 static int 1267 iichid_detach(device_t dev) 1268 { 1269 struct iichid_softc *sc; 1270 int error; 1271 1272 sc = device_get_softc(dev); 1273 error = bus_generic_detach(dev); 1274 if (error) 1275 return (error); 1276 iichid_teardown_interrupt(sc); 1277 if (sc->irq_res != NULL) 1278 bus_release_resource(dev, SYS_RES_IRQ, sc->irq_rid, 1279 sc->irq_res); 1280 #ifdef IICHID_SAMPLING 1281 if (sc->taskqueue != NULL) 1282 taskqueue_free(sc->taskqueue); 1283 sc->taskqueue = NULL; 1284 free(sc->dup_buf, M_DEVBUF); 1285 #endif 1286 free(sc->intr_buf, M_DEVBUF); 1287 mtx_destroy(&sc->mtx); 1288 return (0); 1289 } 1290 1291 static void 1292 iichid_suspend_task(void *context, int pending) 1293 { 1294 struct iichid_softc *sc = context; 1295 1296 iichid_teardown_interrupt(sc); 1297 } 1298 1299 static int 1300 iichid_suspend(device_t dev) 1301 { 1302 struct iichid_softc *sc; 1303 int error; 1304 1305 sc = device_get_softc(dev); 1306 (void)bus_generic_suspend(dev); 1307 /* 1308 * 8.2 - The HOST is going into a deep power optimized state and wishes 1309 * to put all the devices into a low power state also. The HOST 1310 * is recommended to issue a HIPO command to the DEVICE to force 1311 * the DEVICE in to a lower power state. 1312 */ 1313 DPRINTF(sc, "Suspend called, setting device to power_state 1\n"); 1314 error = iichid_set_power_state(sc, IICHID_PS_NULL, IICHID_PS_OFF); 1315 if (error != 0) 1316 DPRINTF(sc, "Could not set power_state, error: %d\n", error); 1317 else 1318 DPRINTF(sc, "Successfully set power_state\n"); 1319 1320 #ifdef IICHID_SAMPLING 1321 if (sc->sampling_rate_slow < 0) 1322 #endif 1323 { 1324 /* 1325 * bus_teardown_intr can not be executed right here as it wants 1326 * to run on certain CPU to interacts with LAPIC while suspend 1327 * thread is bound to CPU0. So run it from taskqueue context. 1328 */ 1329 #ifdef IICHID_SAMPLING 1330 #define suspend_thread sc->taskqueue 1331 #else 1332 #define suspend_thread taskqueue_thread 1333 #endif 1334 taskqueue_enqueue(suspend_thread, &sc->suspend_task); 1335 taskqueue_drain(suspend_thread, &sc->suspend_task); 1336 } 1337 1338 return (0); 1339 } 1340 1341 static int 1342 iichid_resume(device_t dev) 1343 { 1344 struct iichid_softc *sc; 1345 int error; 1346 1347 sc = device_get_softc(dev); 1348 #ifdef IICHID_SAMPLING 1349 if (sc->sampling_rate_slow < 0) 1350 #endif 1351 iichid_setup_interrupt(sc); 1352 1353 DPRINTF(sc, "Resume called, setting device to power_state 0\n"); 1354 error = iichid_set_power_state(sc, IICHID_PS_NULL, IICHID_PS_ON); 1355 if (error != 0) 1356 DPRINTF(sc, "Could not set power_state, error: %d\n", error); 1357 else 1358 DPRINTF(sc, "Successfully set power_state\n"); 1359 (void)bus_generic_resume(dev); 1360 1361 return (0); 1362 } 1363 1364 static device_method_t iichid_methods[] = { 1365 DEVMETHOD(device_probe, iichid_probe), 1366 DEVMETHOD(device_attach, iichid_attach), 1367 DEVMETHOD(device_detach, iichid_detach), 1368 DEVMETHOD(device_suspend, iichid_suspend), 1369 DEVMETHOD(device_resume, iichid_resume), 1370 1371 DEVMETHOD(hid_intr_setup, iichid_intr_setup), 1372 DEVMETHOD(hid_intr_unsetup, iichid_intr_unsetup), 1373 DEVMETHOD(hid_intr_start, iichid_intr_start), 1374 DEVMETHOD(hid_intr_stop, iichid_intr_stop), 1375 DEVMETHOD(hid_intr_poll, iichid_intr_poll), 1376 1377 /* HID interface */ 1378 DEVMETHOD(hid_get_rdesc, iichid_get_rdesc), 1379 DEVMETHOD(hid_read, iichid_read), 1380 DEVMETHOD(hid_write, iichid_write), 1381 DEVMETHOD(hid_get_report, iichid_get_report), 1382 DEVMETHOD(hid_set_report, iichid_set_report), 1383 DEVMETHOD(hid_set_idle, iichid_set_idle), 1384 DEVMETHOD(hid_set_protocol, iichid_set_protocol), 1385 DEVMETHOD(hid_ioctl, iichid_ioctl), 1386 1387 DEVMETHOD_END 1388 }; 1389 1390 static driver_t iichid_driver = { 1391 .name = "iichid", 1392 .methods = iichid_methods, 1393 .size = sizeof(struct iichid_softc), 1394 }; 1395 1396 DRIVER_MODULE(iichid, iicbus, iichid_driver, NULL, NULL); 1397 MODULE_DEPEND(iichid, iicbus, IICBUS_MINVER, IICBUS_PREFVER, IICBUS_MAXVER); 1398 MODULE_DEPEND(iichid, acpi, 1, 1, 1); 1399 MODULE_DEPEND(iichid, hid, 1, 1, 1); 1400 MODULE_DEPEND(iichid, hidbus, 1, 1, 1); 1401 MODULE_VERSION(iichid, 1); 1402 IICBUS_ACPI_PNP_INFO(iichid_ids); 1403