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