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