system/dev/input/i2c-hid/i2c-hid.c - zircon - Git at Google

 // Copyright 2016 The Fuchsia Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include <ddk/debug.h>
 #include <ddk/device.h>
 #include <ddk/driver.h>
 #include <ddk/binding.h>
 #include <ddk/protocol/hidbus.h>

 #include <magenta/assert.h>
 #include <magenta/types.h>
 #include <magenta/device/i2c.h>

 #include <endian.h>
 #include <stdbool.h>
 #include <stdlib.h>
 #include <string.h>
 #include <threads.h>
 #include <unistd.h>

 #define I2C_HID_DEBUG 0

 // Poll interval: 10 ms
 #define I2C_POLL_INTERVAL_USEC 10000

 #define to_i2c_hid(d) containerof(d, i2c_hid_device_t, hiddev)

 typedef struct i2c_hid_desc {
     uint16_t wHIDDescLength;
     uint16_t bcdVersion;
     uint16_t wReportDescLength;
     uint16_t wReportDescRegister;
     uint16_t wInputRegister;
     uint16_t wMaxInputLength;
     uint16_t wOutputRegister;
     uint16_t wMaxOutputLength;
     uint16_t wCommandRegister;
     uint16_t wDataRegister;
     uint16_t wVendorID;
     uint16_t wProductID;
     uint16_t wVersionID;
     uint8_t RESERVED[4];
 } __PACKED i2c_hid_desc_t;

 typedef struct i2c_hid_device {
     mx_device_t* i2cdev;

     mtx_t lock;
     hidbus_ifc_t* ifc;
     void* cookie;

     i2c_hid_desc_t* hiddesc;
     thrd_t irq_thread;
 } i2c_hid_device_t;

 static uint8_t* i2c_hid_prepare_write_read_buffer(uint8_t* buf, int wlen, int rlen) {
     i2c_slave_ioctl_segment_t* segments = (i2c_slave_ioctl_segment_t*)buf;
     segments[0].type = I2C_SEGMENT_TYPE_WRITE;
     segments[0].len = wlen;
     segments[1].type = I2C_SEGMENT_TYPE_READ;
     segments[1].len = rlen;
     segments[2].type = I2C_SEGMENT_TYPE_END;
     segments[2].len = 0;
     return buf + 3 * sizeof(i2c_slave_ioctl_segment_t);
 }

 static mx_status_t i2c_hid_query(void* ctx, uint32_t options, hid_info_t* info) {
     if (!info) {
         return MX_ERR_INVALID_ARGS;
     }
     info->dev_num = 0;
     info->dev_class = HID_DEV_CLASS_OTHER;
     info->boot_device = false;
     return MX_OK;
 }

 static mx_status_t i2c_hid_start(void* ctx, hidbus_ifc_t* ifc, void* cookie) {
     i2c_hid_device_t* hid = ctx;
     mtx_lock(&hid->lock);
     if (hid->ifc) {
         mtx_unlock(&hid->lock);
         return MX_ERR_ALREADY_BOUND;
     }
     hid->ifc = ifc;
     hid->cookie = cookie;
     mtx_unlock(&hid->lock);
     return MX_OK;
 }

 static void i2c_hid_stop(void* ctx) {
     i2c_hid_device_t* hid = ctx;
     mtx_lock(&hid->lock);
     hid->ifc = NULL;
     hid->cookie = NULL;
     mtx_unlock(&hid->lock);
 }

 static mx_status_t i2c_hid_get_descriptor(void* ctx, uint8_t desc_type,
         void** data, size_t* len) {
     if (desc_type != HID_DESC_TYPE_REPORT) {
         return MX_ERR_NOT_FOUND;
     }

     i2c_hid_device_t* hid = ctx;
     size_t desc_len = letoh16(hid->hiddesc->wReportDescLength);
     uint16_t desc_reg = letoh16(hid->hiddesc->wReportDescRegister);

     uint8_t buf[3 * sizeof(i2c_slave_ioctl_segment_t) + 2];
     uint8_t* bufdata = i2c_hid_prepare_write_read_buffer(buf, 2, desc_len);
     *bufdata++ = desc_reg & 0xff;
     *bufdata++ = (desc_reg >> 8 ) & 0xff;

     uint8_t* out = malloc(desc_len);
     if (out == NULL) {
         return MX_ERR_NO_MEMORY;
     }
     size_t actual = 0;
     mx_status_t status = device_ioctl(hid->i2cdev, IOCTL_I2C_SLAVE_TRANSFER,
                                       buf, sizeof(buf), out, desc_len, &actual);
     if (status < 0) {
         dprintf(ERROR, "i2c-hid: could not read HID report descriptor: %d\n", status);
         free(out);
         return MX_ERR_NOT_SUPPORTED;
     }

     *data = out;
     *len = actual;
     return MX_OK;
 }

 // TODO: implement the rest of the HID protocol
 static mx_status_t i2c_hid_get_report(void* ctx, uint8_t rpt_type, uint8_t rpt_id,
         void* data, size_t len) {
     return MX_ERR_NOT_SUPPORTED;
 }

 static mx_status_t i2c_hid_set_report(void* ctx, uint8_t rpt_type, uint8_t rpt_id,
         void* data, size_t len) {
     return MX_ERR_NOT_SUPPORTED;
 }

 static mx_status_t i2c_hid_get_idle(void* ctx, uint8_t rpt_id, uint8_t* duration) {
     return MX_ERR_NOT_SUPPORTED;
 }

 static mx_status_t i2c_hid_set_idle(void* ctx, uint8_t rpt_id, uint8_t duration) {
     return MX_OK;
 }

 static mx_status_t i2c_hid_get_protocol(void* ctx, uint8_t* protocol) {
     return MX_ERR_NOT_SUPPORTED;
 }

 static mx_status_t i2c_hid_set_protocol(void* ctx, uint8_t protocol) {
     return MX_OK;
 }


 static hidbus_protocol_ops_t i2c_hidbus_ops = {
     .query = i2c_hid_query,
     .start = i2c_hid_start,
     .stop = i2c_hid_stop,
     .get_descriptor = i2c_hid_get_descriptor,
     .get_report = i2c_hid_get_report,
     .set_report = i2c_hid_set_report,
     .get_idle = i2c_hid_get_idle,
     .set_idle = i2c_hid_set_idle,
     .get_protocol = i2c_hid_get_protocol,
     .set_protocol = i2c_hid_set_protocol,
 };

 static inline size_t bcdtoa(uint16_t val, char str[static 6], bool pad) {
     memset(str, 0, 6);
     size_t idx = 0;
     if (val >> 12) {
         str[idx++] = (val >> 12) + '0';
     }
     str[idx++] = ((val >> 8) & 0xf) + '0';
     str[idx++] = '.';
     str[idx++] = ((val >> 4) & 0xf) + '0';
     str[idx++] = (val & 0xf) + '0';
     return idx;
 }

 static int i2c_hid_irq_thread(void* arg) {
     i2c_hid_device_t* dev = (i2c_hid_device_t*)arg;
     uint16_t len = letoh16(dev->hiddesc->wMaxInputLength);
     uint8_t* buf = malloc(len);

     mx_time_t last_timeout_warning = 0;
     const mx_duration_t kMinTimeBetweenWarnings = MX_SEC(10);

     // Until we have a way to map the GPIO associated with an i2c slave to an
     // IRQ, we just poll.
     while (true) {
         usleep(I2C_POLL_INTERVAL_USEC);
         size_t actual = 0;
         mx_status_t status = device_read(dev->i2cdev, buf, len, 0, &actual);
         if (status != MX_OK) {
             if (status == MX_ERR_TIMED_OUT) {
                 mx_time_t now = mx_time_get(MX_CLOCK_MONOTONIC);
                 if (now - last_timeout_warning > kMinTimeBetweenWarnings) {
                     dprintf(TRACE, "i2c-hid: device_read timed out\n");
                     last_timeout_warning = now;
                 }
                 continue;
             }
             dprintf(ERROR, "i2c-hid: fatal device_read failure %d\n", status);
             return status;
         }
         if (actual < 2) {
             dprintf(ERROR, "i2c-hid: short read (%zd < 2)!!!\n", actual);
             continue;
         }

         uint16_t report_len = letoh16(*(uint16_t*)buf);
         if ((report_len == 0xffff) || (report_len == 0x3fff) || (report_len == 0x0)) {
             // nothing to read
             continue;
         }
         if ((report_len > actual) || (report_len < 2)) {
             dprintf(ERROR, "i2c-hid: bad report len (rlen %hu, bytes read %zd)!!!\n",
                     report_len, actual);
             continue;
         }
         mtx_lock(&dev->lock);
         if (dev->ifc) {
             dev->ifc->io_queue(dev->cookie, buf + 2, report_len - 2);
         }
         mtx_unlock(&dev->lock);
     }

     // TODO: figure out how to clean up
     free(buf);
     return 0;
 }

 static void i2c_hid_release(void* ctx) {
     MX_PANIC("cannot release an i2c hid device yet!\n");
 }

 static mx_protocol_device_t i2c_hid_dev_ops = {
     .version = DEVICE_OPS_VERSION,
     .release = i2c_hid_release,
 };

 static mx_status_t i2c_hid_bind(void* ctx, mx_device_t* dev, void** cookie) {
     dprintf(TRACE, "i2c_hid_bind\n");

     // Read the i2c HID descriptor
     // TODO: get the address out of ACPI
     uint8_t buf[3 * sizeof(i2c_slave_ioctl_segment_t) + 2];
     uint8_t* data = i2c_hid_prepare_write_read_buffer(buf, 2, 4);
     *data++ = 0x01;
     *data++ = 0x00;
     uint8_t out[4];
     size_t actual = 0;
     mx_status_t ret = device_ioctl(dev, IOCTL_I2C_SLAVE_TRANSFER, buf, sizeof(buf), out, sizeof(out), &actual);
     if (ret < 0 || actual != sizeof(out)) {
         dprintf(ERROR, "i2c-hid: could not read HID descriptor: %d\n", ret);
         return MX_ERR_NOT_SUPPORTED;
     }
     i2c_hid_desc_t* i2c_hid_desc_hdr = (i2c_hid_desc_t*)out;
     uint16_t desc_len = letoh16(i2c_hid_desc_hdr->wHIDDescLength);

     i2c_hid_device_t* i2chid = calloc(1, sizeof(i2c_hid_device_t));
     if (i2chid == NULL) {
         return MX_ERR_NO_MEMORY;
     }
     i2chid->i2cdev = dev;
     i2chid->hiddesc = malloc(desc_len);

     i2c_hid_prepare_write_read_buffer(buf, 2, desc_len);
     actual = 0;
     ret = device_ioctl(dev, IOCTL_I2C_SLAVE_TRANSFER, buf, sizeof(buf), i2chid->hiddesc, desc_len, &actual);
     if (ret < 0 || actual != desc_len) {
         dprintf(ERROR, "i2c-hid: could not read HID descriptor: %d\n", ret);
         free(i2chid->hiddesc);
         free(i2chid);
         return MX_ERR_NOT_SUPPORTED;
     }

     dprintf(TRACE, "i2c-hid: desc:\n");
     dprintf(TRACE, "  report desc len: %u\n", letoh16(i2chid->hiddesc->wReportDescLength));
     dprintf(TRACE, "  report desc reg: %u\n", letoh16(i2chid->hiddesc->wReportDescRegister));
     dprintf(TRACE, "  input reg:       %u\n", letoh16(i2chid->hiddesc->wInputRegister));
     dprintf(TRACE, "  max input len:   %u\n", letoh16(i2chid->hiddesc->wMaxInputLength));
     dprintf(TRACE, "  output reg:      %u\n", letoh16(i2chid->hiddesc->wOutputRegister));
     dprintf(TRACE, "  max output len:  %u\n", letoh16(i2chid->hiddesc->wMaxOutputLength));
     dprintf(TRACE, "  command reg:     %u\n", letoh16(i2chid->hiddesc->wCommandRegister));
     dprintf(TRACE, "  data reg:        %u\n", letoh16(i2chid->hiddesc->wDataRegister));
     dprintf(TRACE, "  vendor id:       %x\n", i2chid->hiddesc->wVendorID);
     dprintf(TRACE, "  product id:      %x\n", i2chid->hiddesc->wProductID);
     dprintf(TRACE, "  version id:      %x\n", i2chid->hiddesc->wVersionID);

     device_add_args_t args = {
         .version = DEVICE_ADD_ARGS_VERSION,
         .name = "i2c-hid",
         .ctx = i2chid,
         .ops = &i2c_hid_dev_ops,
         .proto_id = MX_PROTOCOL_HIDBUS,
         .proto_ops = &i2c_hidbus_ops,
     };

     mx_status_t status = device_add(i2chid->i2cdev, &args, NULL);
     if (status != MX_OK) {
         dprintf(ERROR, "i2c-hid: could not add device: %d\n", status);
         free(i2chid->hiddesc);
         free(i2chid);
         return status;
     }

     ret = thrd_create_with_name(&i2chid->irq_thread, i2c_hid_irq_thread, i2chid, "i2c-hid-irq");
     if (ret != thrd_success) {
         dprintf(ERROR, "i2c-hid: could not create irq thread: %d\n", ret);
         free(i2chid->hiddesc);
         free(i2chid);
         // TODO: map thrd_* status codes to MX_ERR_* status codes
         return MX_ERR_INTERNAL;
     }

     return MX_OK;
 }

 static mx_driver_ops_t i2c_hid_driver_ops = {
     .version = DRIVER_OPS_VERSION,
     .bind = i2c_hid_bind,
 };

 MAGENTA_DRIVER_BEGIN(i2c_hid, i2c_hid_driver_ops, "magenta", "0.1", 9)
     BI_ABORT_IF(NE, BIND_PCI_VID, 0x8086),

     // Acer12
     BI_GOTO_IF(NE, BIND_PCI_DID, 0x9d61, 0),
     BI_MATCH_IF(EQ, BIND_I2C_ADDR, 0x0010),

     BI_LABEL(0),
     BI_GOTO_IF(NE, BIND_PCI_DID, 0x9d60, 0),
     BI_MATCH_IF(EQ, BIND_I2C_ADDR, 0x000A),

     BI_LABEL(0),
     BI_ABORT_IF(NE, BIND_PCI_DID, 0x9d62),
     BI_MATCH_IF(EQ, BIND_I2C_ADDR, 0x0049),

 MAGENTA_DRIVER_END(i2c_hid)
	// Copyright 2016 The Fuchsia Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include <ddk/debug.h>
	#include <ddk/device.h>
	#include <ddk/driver.h>
	#include <ddk/binding.h>
	#include <ddk/protocol/hidbus.h>

	#include <magenta/assert.h>
	#include <magenta/types.h>
	#include <magenta/device/i2c.h>

	#include <endian.h>
	#include <stdbool.h>
	#include <stdlib.h>
	#include <string.h>
	#include <threads.h>
	#include <unistd.h>

	#define I2C_HID_DEBUG 0

	// Poll interval: 10 ms
	#define I2C_POLL_INTERVAL_USEC 10000

	#define to_i2c_hid(d) containerof(d, i2c_hid_device_t, hiddev)

	typedef struct i2c_hid_desc {
	uint16_t wHIDDescLength;
	uint16_t bcdVersion;
	uint16_t wReportDescLength;
	uint16_t wReportDescRegister;
	uint16_t wInputRegister;
	uint16_t wMaxInputLength;
	uint16_t wOutputRegister;
	uint16_t wMaxOutputLength;
	uint16_t wCommandRegister;
	uint16_t wDataRegister;
	uint16_t wVendorID;
	uint16_t wProductID;
	uint16_t wVersionID;
	uint8_t RESERVED[4];
	} __PACKED i2c_hid_desc_t;

	typedef struct i2c_hid_device {
	mx_device_t* i2cdev;

	mtx_t lock;
	hidbus_ifc_t* ifc;
	void* cookie;

	i2c_hid_desc_t* hiddesc;
	thrd_t irq_thread;
	} i2c_hid_device_t;

	static uint8_t* i2c_hid_prepare_write_read_buffer(uint8_t* buf, int wlen, int rlen) {
	i2c_slave_ioctl_segment_t* segments = (i2c_slave_ioctl_segment_t*)buf;
	segments[0].type = I2C_SEGMENT_TYPE_WRITE;
	segments[0].len = wlen;
	segments[1].type = I2C_SEGMENT_TYPE_READ;
	segments[1].len = rlen;
	segments[2].type = I2C_SEGMENT_TYPE_END;
	segments[2].len = 0;
	return buf + 3 * sizeof(i2c_slave_ioctl_segment_t);
	}

	static mx_status_t i2c_hid_query(void* ctx, uint32_t options, hid_info_t* info) {
	if (!info) {
	return MX_ERR_INVALID_ARGS;
	}
	info->dev_num = 0;
	info->dev_class = HID_DEV_CLASS_OTHER;
	info->boot_device = false;
	return MX_OK;
	}

	static mx_status_t i2c_hid_start(void* ctx, hidbus_ifc_t* ifc, void* cookie) {
	i2c_hid_device_t* hid = ctx;
	mtx_lock(&hid->lock);
	if (hid->ifc) {
	mtx_unlock(&hid->lock);
	return MX_ERR_ALREADY_BOUND;
	}
	hid->ifc = ifc;
	hid->cookie = cookie;
	mtx_unlock(&hid->lock);
	return MX_OK;
	}

	static void i2c_hid_stop(void* ctx) {
	i2c_hid_device_t* hid = ctx;
	mtx_lock(&hid->lock);
	hid->ifc = NULL;
	hid->cookie = NULL;
	mtx_unlock(&hid->lock);
	}

	static mx_status_t i2c_hid_get_descriptor(void* ctx, uint8_t desc_type,
	void** data, size_t* len) {
	if (desc_type != HID_DESC_TYPE_REPORT) {
	return MX_ERR_NOT_FOUND;
	}

	i2c_hid_device_t* hid = ctx;
	size_t desc_len = letoh16(hid->hiddesc->wReportDescLength);
	uint16_t desc_reg = letoh16(hid->hiddesc->wReportDescRegister);

	uint8_t buf[3 * sizeof(i2c_slave_ioctl_segment_t) + 2];
	uint8_t* bufdata = i2c_hid_prepare_write_read_buffer(buf, 2, desc_len);
	*bufdata++ = desc_reg & 0xff;
	*bufdata++ = (desc_reg >> 8 ) & 0xff;

	uint8_t* out = malloc(desc_len);
	if (out == NULL) {
	return MX_ERR_NO_MEMORY;
	}
	size_t actual = 0;
	mx_status_t status = device_ioctl(hid->i2cdev, IOCTL_I2C_SLAVE_TRANSFER,
	buf, sizeof(buf), out, desc_len, &actual);
	if (status < 0) {
	dprintf(ERROR, "i2c-hid: could not read HID report descriptor: %d\n", status);
	free(out);
	return MX_ERR_NOT_SUPPORTED;
	}

	*data = out;
	*len = actual;
	return MX_OK;
	}

	// TODO: implement the rest of the HID protocol
	static mx_status_t i2c_hid_get_report(void* ctx, uint8_t rpt_type, uint8_t rpt_id,
	void* data, size_t len) {
	return MX_ERR_NOT_SUPPORTED;
	}

	static mx_status_t i2c_hid_set_report(void* ctx, uint8_t rpt_type, uint8_t rpt_id,
	void* data, size_t len) {
	return MX_ERR_NOT_SUPPORTED;
	}

	static mx_status_t i2c_hid_get_idle(void* ctx, uint8_t rpt_id, uint8_t* duration) {
	return MX_ERR_NOT_SUPPORTED;
	}

	static mx_status_t i2c_hid_set_idle(void* ctx, uint8_t rpt_id, uint8_t duration) {
	return MX_OK;
	}

	static mx_status_t i2c_hid_get_protocol(void* ctx, uint8_t* protocol) {
	return MX_ERR_NOT_SUPPORTED;
	}

	static mx_status_t i2c_hid_set_protocol(void* ctx, uint8_t protocol) {
	return MX_OK;
	}


	static hidbus_protocol_ops_t i2c_hidbus_ops = {
	.query = i2c_hid_query,
	.start = i2c_hid_start,
	.stop = i2c_hid_stop,
	.get_descriptor = i2c_hid_get_descriptor,
	.get_report = i2c_hid_get_report,
	.set_report = i2c_hid_set_report,
	.get_idle = i2c_hid_get_idle,
	.set_idle = i2c_hid_set_idle,
	.get_protocol = i2c_hid_get_protocol,
	.set_protocol = i2c_hid_set_protocol,
	};

	static inline size_t bcdtoa(uint16_t val, char str[static 6], bool pad) {
	memset(str, 0, 6);
	size_t idx = 0;
	if (val >> 12) {
	str[idx++] = (val >> 12) + '0';
	}
	str[idx++] = ((val >> 8) & 0xf) + '0';
	str[idx++] = '.';
	str[idx++] = ((val >> 4) & 0xf) + '0';
	str[idx++] = (val & 0xf) + '0';
	return idx;
	}

	static int i2c_hid_irq_thread(void* arg) {
	i2c_hid_device_t* dev = (i2c_hid_device_t*)arg;
	uint16_t len = letoh16(dev->hiddesc->wMaxInputLength);
	uint8_t* buf = malloc(len);

	mx_time_t last_timeout_warning = 0;
	const mx_duration_t kMinTimeBetweenWarnings = MX_SEC(10);

	// Until we have a way to map the GPIO associated with an i2c slave to an
	// IRQ, we just poll.
	while (true) {
	usleep(I2C_POLL_INTERVAL_USEC);
	size_t actual = 0;
	mx_status_t status = device_read(dev->i2cdev, buf, len, 0, &actual);
	if (status != MX_OK) {
	if (status == MX_ERR_TIMED_OUT) {
	mx_time_t now = mx_time_get(MX_CLOCK_MONOTONIC);
	if (now - last_timeout_warning > kMinTimeBetweenWarnings) {
	dprintf(TRACE, "i2c-hid: device_read timed out\n");
	last_timeout_warning = now;
	}
	continue;
	}
	dprintf(ERROR, "i2c-hid: fatal device_read failure %d\n", status);
	return status;
	}
	if (actual < 2) {
	dprintf(ERROR, "i2c-hid: short read (%zd < 2)!!!\n", actual);
	continue;
	}

	uint16_t report_len = letoh16((uint16_t)buf);
	if ((report_len == 0xffff) \|\| (report_len == 0x3fff) \|\| (report_len == 0x0)) {
	// nothing to read
	continue;
	}
	if ((report_len > actual) \|\| (report_len < 2)) {
	dprintf(ERROR, "i2c-hid: bad report len (rlen %hu, bytes read %zd)!!!\n",
	report_len, actual);
	continue;
	}
	mtx_lock(&dev->lock);
	if (dev->ifc) {
	dev->ifc->io_queue(dev->cookie, buf + 2, report_len - 2);
	}
	mtx_unlock(&dev->lock);
	}

	// TODO: figure out how to clean up
	free(buf);
	return 0;
	}

	static void i2c_hid_release(void* ctx) {
	MX_PANIC("cannot release an i2c hid device yet!\n");
	}

	static mx_protocol_device_t i2c_hid_dev_ops = {
	.version = DEVICE_OPS_VERSION,
	.release = i2c_hid_release,
	};

	static mx_status_t i2c_hid_bind(void* ctx, mx_device_t* dev, void** cookie) {
	dprintf(TRACE, "i2c_hid_bind\n");

	// Read the i2c HID descriptor
	// TODO: get the address out of ACPI
	uint8_t buf[3 * sizeof(i2c_slave_ioctl_segment_t) + 2];
	uint8_t* data = i2c_hid_prepare_write_read_buffer(buf, 2, 4);
	*data++ = 0x01;
	*data++ = 0x00;
	uint8_t out[4];
	size_t actual = 0;
	mx_status_t ret = device_ioctl(dev, IOCTL_I2C_SLAVE_TRANSFER, buf, sizeof(buf), out, sizeof(out), &actual);
	if (ret < 0 \|\| actual != sizeof(out)) {
	dprintf(ERROR, "i2c-hid: could not read HID descriptor: %d\n", ret);
	return MX_ERR_NOT_SUPPORTED;
	}
	i2c_hid_desc_t* i2c_hid_desc_hdr = (i2c_hid_desc_t*)out;
	uint16_t desc_len = letoh16(i2c_hid_desc_hdr->wHIDDescLength);

	i2c_hid_device_t* i2chid = calloc(1, sizeof(i2c_hid_device_t));
	if (i2chid == NULL) {
	return MX_ERR_NO_MEMORY;
	}
	i2chid->i2cdev = dev;
	i2chid->hiddesc = malloc(desc_len);

	i2c_hid_prepare_write_read_buffer(buf, 2, desc_len);
	actual = 0;
	ret = device_ioctl(dev, IOCTL_I2C_SLAVE_TRANSFER, buf, sizeof(buf), i2chid->hiddesc, desc_len, &actual);
	if (ret < 0 \|\| actual != desc_len) {
	dprintf(ERROR, "i2c-hid: could not read HID descriptor: %d\n", ret);
	free(i2chid->hiddesc);
	free(i2chid);
	return MX_ERR_NOT_SUPPORTED;
	}

	dprintf(TRACE, "i2c-hid: desc:\n");
	dprintf(TRACE, " report desc len: %u\n", letoh16(i2chid->hiddesc->wReportDescLength));
	dprintf(TRACE, " report desc reg: %u\n", letoh16(i2chid->hiddesc->wReportDescRegister));
	dprintf(TRACE, " input reg: %u\n", letoh16(i2chid->hiddesc->wInputRegister));
	dprintf(TRACE, " max input len: %u\n", letoh16(i2chid->hiddesc->wMaxInputLength));
	dprintf(TRACE, " output reg: %u\n", letoh16(i2chid->hiddesc->wOutputRegister));
	dprintf(TRACE, " max output len: %u\n", letoh16(i2chid->hiddesc->wMaxOutputLength));
	dprintf(TRACE, " command reg: %u\n", letoh16(i2chid->hiddesc->wCommandRegister));
	dprintf(TRACE, " data reg: %u\n", letoh16(i2chid->hiddesc->wDataRegister));
	dprintf(TRACE, " vendor id: %x\n", i2chid->hiddesc->wVendorID);
	dprintf(TRACE, " product id: %x\n", i2chid->hiddesc->wProductID);
	dprintf(TRACE, " version id: %x\n", i2chid->hiddesc->wVersionID);

	device_add_args_t args = {
	.version = DEVICE_ADD_ARGS_VERSION,
	.name = "i2c-hid",
	.ctx = i2chid,
	.ops = &i2c_hid_dev_ops,
	.proto_id = MX_PROTOCOL_HIDBUS,
	.proto_ops = &i2c_hidbus_ops,
	};

	mx_status_t status = device_add(i2chid->i2cdev, &args, NULL);
	if (status != MX_OK) {
	dprintf(ERROR, "i2c-hid: could not add device: %d\n", status);
	free(i2chid->hiddesc);
	free(i2chid);
	return status;
	}

	ret = thrd_create_with_name(&i2chid->irq_thread, i2c_hid_irq_thread, i2chid, "i2c-hid-irq");
	if (ret != thrd_success) {
	dprintf(ERROR, "i2c-hid: could not create irq thread: %d\n", ret);
	free(i2chid->hiddesc);
	free(i2chid);
	// TODO: map thrd_* status codes to MX_ERR_* status codes
	return MX_ERR_INTERNAL;
	}

	return MX_OK;
	}

	static mx_driver_ops_t i2c_hid_driver_ops = {
	.version = DRIVER_OPS_VERSION,
	.bind = i2c_hid_bind,
	};

	MAGENTA_DRIVER_BEGIN(i2c_hid, i2c_hid_driver_ops, "magenta", "0.1", 9)
	BI_ABORT_IF(NE, BIND_PCI_VID, 0x8086),

	// Acer12
	BI_GOTO_IF(NE, BIND_PCI_DID, 0x9d61, 0),
	BI_MATCH_IF(EQ, BIND_I2C_ADDR, 0x0010),

	BI_LABEL(0),
	BI_GOTO_IF(NE, BIND_PCI_DID, 0x9d60, 0),
	BI_MATCH_IF(EQ, BIND_I2C_ADDR, 0x000A),

	BI_LABEL(0),
	BI_ABORT_IF(NE, BIND_PCI_DID, 0x9d62),
	BI_MATCH_IF(EQ, BIND_I2C_ADDR, 0x0049),

	MAGENTA_DRIVER_END(i2c_hid)