1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * hid-cp2112.c - Silicon Labs HID USB to SMBus master bridge
   4 * Copyright (c) 2013,2014 Uplogix, Inc.
   5 * David Barksdale <dbarksdale@uplogix.com>
   6 */
   7
   8/*
   9 * The Silicon Labs CP2112 chip is a USB HID device which provides an
  10 * SMBus controller for talking to slave devices and 8 GPIO pins. The
  11 * host communicates with the CP2112 via raw HID reports.
  12 *
  13 * Data Sheet:
  14 *   https://www.silabs.com/Support%20Documents/TechnicalDocs/CP2112.pdf
  15 * Programming Interface Specification:
  16 *   https://www.silabs.com/documents/public/application-notes/an495-cp2112-interface-specification.pdf
  17 */
  18
  19#include <linux/gpio/consumer.h>
  20#include <linux/gpio/machine.h>
  21#include <linux/gpio/driver.h>
  22#include <linux/hid.h>
  23#include <linux/hidraw.h>
  24#include <linux/i2c.h>
  25#include <linux/module.h>
  26#include <linux/nls.h>
  27#include <linux/usb/ch9.h>
  28#include "hid-ids.h"
  29
  30#define CP2112_REPORT_MAX_LENGTH		64
  31#define CP2112_GPIO_CONFIG_LENGTH		5
  32#define CP2112_GPIO_GET_LENGTH			2
  33#define CP2112_GPIO_SET_LENGTH			3
  34
  35enum {
  36	CP2112_GPIO_CONFIG		= 0x02,
  37	CP2112_GPIO_GET			= 0x03,
  38	CP2112_GPIO_SET			= 0x04,
  39	CP2112_GET_VERSION_INFO		= 0x05,
  40	CP2112_SMBUS_CONFIG		= 0x06,
  41	CP2112_DATA_READ_REQUEST	= 0x10,
  42	CP2112_DATA_WRITE_READ_REQUEST	= 0x11,
  43	CP2112_DATA_READ_FORCE_SEND	= 0x12,
  44	CP2112_DATA_READ_RESPONSE	= 0x13,
  45	CP2112_DATA_WRITE_REQUEST	= 0x14,
  46	CP2112_TRANSFER_STATUS_REQUEST	= 0x15,
  47	CP2112_TRANSFER_STATUS_RESPONSE	= 0x16,
  48	CP2112_CANCEL_TRANSFER		= 0x17,
  49	CP2112_LOCK_BYTE		= 0x20,
  50	CP2112_USB_CONFIG		= 0x21,
  51	CP2112_MANUFACTURER_STRING	= 0x22,
  52	CP2112_PRODUCT_STRING		= 0x23,
  53	CP2112_SERIAL_STRING		= 0x24,
  54};
  55
  56enum {
  57	STATUS0_IDLE		= 0x00,
  58	STATUS0_BUSY		= 0x01,
  59	STATUS0_COMPLETE	= 0x02,
  60	STATUS0_ERROR		= 0x03,
  61};
  62
  63enum {
  64	STATUS1_TIMEOUT_NACK		= 0x00,
  65	STATUS1_TIMEOUT_BUS		= 0x01,
  66	STATUS1_ARBITRATION_LOST	= 0x02,
  67	STATUS1_READ_INCOMPLETE		= 0x03,
  68	STATUS1_WRITE_INCOMPLETE	= 0x04,
  69	STATUS1_SUCCESS			= 0x05,
  70};
  71
  72struct cp2112_smbus_config_report {
  73	u8 report;		/* CP2112_SMBUS_CONFIG */
  74	__be32 clock_speed;	/* Hz */
  75	u8 device_address;	/* Stored in the upper 7 bits */
  76	u8 auto_send_read;	/* 1 = enabled, 0 = disabled */
  77	__be16 write_timeout;	/* ms, 0 = no timeout */
  78	__be16 read_timeout;	/* ms, 0 = no timeout */
  79	u8 scl_low_timeout;	/* 1 = enabled, 0 = disabled */
  80	__be16 retry_time;	/* # of retries, 0 = no limit */
  81} __packed;
  82
  83struct cp2112_usb_config_report {
  84	u8 report;	/* CP2112_USB_CONFIG */
  85	__le16 vid;	/* Vendor ID */
  86	__le16 pid;	/* Product ID */
  87	u8 max_power;	/* Power requested in 2mA units */
  88	u8 power_mode;	/* 0x00 = bus powered
  89			   0x01 = self powered & regulator off
  90			   0x02 = self powered & regulator on */
  91	u8 release_major;
  92	u8 release_minor;
  93	u8 mask;	/* What fields to program */
  94} __packed;
  95
  96struct cp2112_read_req_report {
  97	u8 report;	/* CP2112_DATA_READ_REQUEST */
  98	u8 slave_address;
  99	__be16 length;
 100} __packed;
 101
 102struct cp2112_write_read_req_report {
 103	u8 report;	/* CP2112_DATA_WRITE_READ_REQUEST */
 104	u8 slave_address;
 105	__be16 length;
 106	u8 target_address_length;
 107	u8 target_address[16];
 108} __packed;
 109
 110struct cp2112_write_req_report {
 111	u8 report;	/* CP2112_DATA_WRITE_REQUEST */
 112	u8 slave_address;
 113	u8 length;
 114	u8 data[61];
 115} __packed;
 116
 117struct cp2112_force_read_report {
 118	u8 report;	/* CP2112_DATA_READ_FORCE_SEND */
 119	__be16 length;
 120} __packed;
 121
 122struct cp2112_xfer_status_report {
 123	u8 report;	/* CP2112_TRANSFER_STATUS_RESPONSE */
 124	u8 status0;	/* STATUS0_* */
 125	u8 status1;	/* STATUS1_* */
 126	__be16 retries;
 127	__be16 length;
 128} __packed;
 129
 130struct cp2112_string_report {
 131	u8 dummy;		/* force .string to be aligned */
 132	u8 report;		/* CP2112_*_STRING */
 133	u8 length;		/* length in bytes of everyting after .report */
 134	u8 type;		/* USB_DT_STRING */
 135	wchar_t string[30];	/* UTF16_LITTLE_ENDIAN string */
 136} __packed;
 137
 138/* Number of times to request transfer status before giving up waiting for a
 139   transfer to complete. This may need to be changed if SMBUS clock, retries,
 140   or read/write/scl_low timeout settings are changed. */
 141static const int XFER_STATUS_RETRIES = 10;
 142
 143/* Time in ms to wait for a CP2112_DATA_READ_RESPONSE or
 144   CP2112_TRANSFER_STATUS_RESPONSE. */
 145static const int RESPONSE_TIMEOUT = 50;
 146
 147static const struct hid_device_id cp2112_devices[] = {
 148	{ HID_USB_DEVICE(USB_VENDOR_ID_CYGNAL, USB_DEVICE_ID_CYGNAL_CP2112) },
 149	{ }
 150};
 151MODULE_DEVICE_TABLE(hid, cp2112_devices);
 152
 153struct cp2112_device {
 154	struct i2c_adapter adap;
 155	struct hid_device *hdev;
 156	wait_queue_head_t wait;
 157	u8 read_data[61];
 158	u8 read_length;
 159	u8 hwversion;
 160	int xfer_status;
 161	atomic_t read_avail;
 162	atomic_t xfer_avail;
 163	struct gpio_chip gc;
 164	u8 *in_out_buffer;
 165	struct mutex lock;
 166
 167	struct gpio_desc *desc[8];
 168	bool gpio_poll;
 169	struct delayed_work gpio_poll_worker;
 170	unsigned long irq_mask;
 171	u8 gpio_prev_state;
 172};
 173
 174static int gpio_push_pull = 0xFF;
 175module_param(gpio_push_pull, int, S_IRUGO | S_IWUSR);
 176MODULE_PARM_DESC(gpio_push_pull, "GPIO push-pull configuration bitmask");
 177
 178static int cp2112_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
 179{
 180	struct cp2112_device *dev = gpiochip_get_data(chip);
 181	struct hid_device *hdev = dev->hdev;
 182	u8 *buf = dev->in_out_buffer;
 183	int ret;
 184
 185	mutex_lock(&dev->lock);
 186
 187	ret = hid_hw_raw_request(hdev, CP2112_GPIO_CONFIG, buf,
 188				 CP2112_GPIO_CONFIG_LENGTH, HID_FEATURE_REPORT,
 189				 HID_REQ_GET_REPORT);
 190	if (ret != CP2112_GPIO_CONFIG_LENGTH) {
 191		hid_err(hdev, "error requesting GPIO config: %d\n", ret);
 192		if (ret >= 0)
 193			ret = -EIO;
 194		goto exit;
 195	}
 196
 197	buf[1] &= ~(1 << offset);
 198	buf[2] = gpio_push_pull;
 199
 200	ret = hid_hw_raw_request(hdev, CP2112_GPIO_CONFIG, buf,
 201				 CP2112_GPIO_CONFIG_LENGTH, HID_FEATURE_REPORT,
 202				 HID_REQ_SET_REPORT);
 203	if (ret != CP2112_GPIO_CONFIG_LENGTH) {
 204		hid_err(hdev, "error setting GPIO config: %d\n", ret);
 205		if (ret >= 0)
 206			ret = -EIO;
 207		goto exit;
 208	}
 209
 210	ret = 0;
 211
 212exit:
 213	mutex_unlock(&dev->lock);
 214	return ret;
 215}
 216
 217static void cp2112_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 218{
 219	struct cp2112_device *dev = gpiochip_get_data(chip);
 220	struct hid_device *hdev = dev->hdev;
 221	u8 *buf = dev->in_out_buffer;
 222	int ret;
 223
 224	mutex_lock(&dev->lock);
 225
 226	buf[0] = CP2112_GPIO_SET;
 227	buf[1] = value ? 0xff : 0;
 228	buf[2] = 1 << offset;
 229
 230	ret = hid_hw_raw_request(hdev, CP2112_GPIO_SET, buf,
 231				 CP2112_GPIO_SET_LENGTH, HID_FEATURE_REPORT,
 232				 HID_REQ_SET_REPORT);
 233	if (ret < 0)
 234		hid_err(hdev, "error setting GPIO values: %d\n", ret);
 235
 236	mutex_unlock(&dev->lock);
 237}
 238
 239static int cp2112_gpio_get_all(struct gpio_chip *chip)
 240{
 241	struct cp2112_device *dev = gpiochip_get_data(chip);
 242	struct hid_device *hdev = dev->hdev;
 243	u8 *buf = dev->in_out_buffer;
 244	int ret;
 245
 246	mutex_lock(&dev->lock);
 247
 248	ret = hid_hw_raw_request(hdev, CP2112_GPIO_GET, buf,
 249				 CP2112_GPIO_GET_LENGTH, HID_FEATURE_REPORT,
 250				 HID_REQ_GET_REPORT);
 251	if (ret != CP2112_GPIO_GET_LENGTH) {
 252		hid_err(hdev, "error requesting GPIO values: %d\n", ret);
 253		ret = ret < 0 ? ret : -EIO;
 254		goto exit;
 255	}
 256
 257	ret = buf[1];
 258
 259exit:
 260	mutex_unlock(&dev->lock);
 261
 262	return ret;
 263}
 264
 265static int cp2112_gpio_get(struct gpio_chip *chip, unsigned int offset)
 266{
 267	int ret;
 268
 269	ret = cp2112_gpio_get_all(chip);
 270	if (ret < 0)
 271		return ret;
 272
 273	return (ret >> offset) & 1;
 274}
 275
 276static int cp2112_gpio_direction_output(struct gpio_chip *chip,
 277					unsigned offset, int value)
 278{
 279	struct cp2112_device *dev = gpiochip_get_data(chip);
 280	struct hid_device *hdev = dev->hdev;
 281	u8 *buf = dev->in_out_buffer;
 282	int ret;
 283
 284	mutex_lock(&dev->lock);
 285
 286	ret = hid_hw_raw_request(hdev, CP2112_GPIO_CONFIG, buf,
 287				 CP2112_GPIO_CONFIG_LENGTH, HID_FEATURE_REPORT,
 288				 HID_REQ_GET_REPORT);
 289	if (ret != CP2112_GPIO_CONFIG_LENGTH) {
 290		hid_err(hdev, "error requesting GPIO config: %d\n", ret);
 291		goto fail;
 292	}
 293
 294	buf[1] |= 1 << offset;
 295	buf[2] = gpio_push_pull;
 296
 297	ret = hid_hw_raw_request(hdev, CP2112_GPIO_CONFIG, buf,
 298				 CP2112_GPIO_CONFIG_LENGTH, HID_FEATURE_REPORT,
 299				 HID_REQ_SET_REPORT);
 300	if (ret < 0) {
 301		hid_err(hdev, "error setting GPIO config: %d\n", ret);
 302		goto fail;
 303	}
 304
 305	mutex_unlock(&dev->lock);
 306
 307	/*
 308	 * Set gpio value when output direction is already set,
 309	 * as specified in AN495, Rev. 0.2, cpt. 4.4
 310	 */
 311	cp2112_gpio_set(chip, offset, value);
 312
 313	return 0;
 314
 315fail:
 316	mutex_unlock(&dev->lock);
 317	return ret < 0 ? ret : -EIO;
 318}
 319
 320static int cp2112_hid_get(struct hid_device *hdev, unsigned char report_number,
 321			  u8 *data, size_t count, unsigned char report_type)
 322{
 323	u8 *buf;
 324	int ret;
 325
 326	buf = kmalloc(count, GFP_KERNEL);
 327	if (!buf)
 328		return -ENOMEM;
 329
 330	ret = hid_hw_raw_request(hdev, report_number, buf, count,
 331				       report_type, HID_REQ_GET_REPORT);
 332	memcpy(data, buf, count);
 333	kfree(buf);
 334	return ret;
 335}
 336
 337static int cp2112_hid_output(struct hid_device *hdev, u8 *data, size_t count,
 338			     unsigned char report_type)
 339{
 340	u8 *buf;
 341	int ret;
 342
 343	buf = kmemdup(data, count, GFP_KERNEL);
 344	if (!buf)
 345		return -ENOMEM;
 346
 347	if (report_type == HID_OUTPUT_REPORT)
 348		ret = hid_hw_output_report(hdev, buf, count);
 349	else
 350		ret = hid_hw_raw_request(hdev, buf[0], buf, count, report_type,
 351				HID_REQ_SET_REPORT);
 352
 353	kfree(buf);
 354	return ret;
 355}
 356
 357static int cp2112_wait(struct cp2112_device *dev, atomic_t *avail)
 358{
 359	int ret = 0;
 360
 361	/* We have sent either a CP2112_TRANSFER_STATUS_REQUEST or a
 362	 * CP2112_DATA_READ_FORCE_SEND and we are waiting for the response to
 363	 * come in cp2112_raw_event or timeout. There will only be one of these
 364	 * in flight at any one time. The timeout is extremely large and is a
 365	 * last resort if the CP2112 has died. If we do timeout we don't expect
 366	 * to receive the response which would cause data races, it's not like
 367	 * we can do anything about it anyway.
 368	 */
 369	ret = wait_event_interruptible_timeout(dev->wait,
 370		atomic_read(avail), msecs_to_jiffies(RESPONSE_TIMEOUT));
 371	if (-ERESTARTSYS == ret)
 372		return ret;
 373	if (!ret)
 374		return -ETIMEDOUT;
 375
 376	atomic_set(avail, 0);
 377	return 0;
 378}
 379
 380static int cp2112_xfer_status(struct cp2112_device *dev)
 381{
 382	struct hid_device *hdev = dev->hdev;
 383	u8 buf[2];
 384	int ret;
 385
 386	buf[0] = CP2112_TRANSFER_STATUS_REQUEST;
 387	buf[1] = 0x01;
 388	atomic_set(&dev->xfer_avail, 0);
 389
 390	ret = cp2112_hid_output(hdev, buf, 2, HID_OUTPUT_REPORT);
 391	if (ret < 0) {
 392		hid_warn(hdev, "Error requesting status: %d\n", ret);
 393		return ret;
 394	}
 395
 396	ret = cp2112_wait(dev, &dev->xfer_avail);
 397	if (ret)
 398		return ret;
 399
 400	return dev->xfer_status;
 401}
 402
 403static int cp2112_read(struct cp2112_device *dev, u8 *data, size_t size)
 404{
 405	struct hid_device *hdev = dev->hdev;
 406	struct cp2112_force_read_report report;
 407	int ret;
 408
 409	if (size > sizeof(dev->read_data))
 410		size = sizeof(dev->read_data);
 411	report.report = CP2112_DATA_READ_FORCE_SEND;
 412	report.length = cpu_to_be16(size);
 413
 414	atomic_set(&dev->read_avail, 0);
 415
 416	ret = cp2112_hid_output(hdev, &report.report, sizeof(report),
 417				HID_OUTPUT_REPORT);
 418	if (ret < 0) {
 419		hid_warn(hdev, "Error requesting data: %d\n", ret);
 420		return ret;
 421	}
 422
 423	ret = cp2112_wait(dev, &dev->read_avail);
 424	if (ret)
 425		return ret;
 426
 427	hid_dbg(hdev, "read %d of %zd bytes requested\n",
 428		dev->read_length, size);
 429
 430	if (size > dev->read_length)
 431		size = dev->read_length;
 432
 433	memcpy(data, dev->read_data, size);
 434	return dev->read_length;
 435}
 436
 437static int cp2112_read_req(void *buf, u8 slave_address, u16 length)
 438{
 439	struct cp2112_read_req_report *report = buf;
 440
 441	if (length < 1 || length > 512)
 442		return -EINVAL;
 443
 444	report->report = CP2112_DATA_READ_REQUEST;
 445	report->slave_address = slave_address << 1;
 446	report->length = cpu_to_be16(length);
 447	return sizeof(*report);
 448}
 449
 450static int cp2112_write_read_req(void *buf, u8 slave_address, u16 length,
 451				 u8 command, u8 *data, u8 data_length)
 452{
 453	struct cp2112_write_read_req_report *report = buf;
 454
 455	if (length < 1 || length > 512
 456	    || data_length > sizeof(report->target_address) - 1)
 457		return -EINVAL;
 458
 459	report->report = CP2112_DATA_WRITE_READ_REQUEST;
 460	report->slave_address = slave_address << 1;
 461	report->length = cpu_to_be16(length);
 462	report->target_address_length = data_length + 1;
 463	report->target_address[0] = command;
 464	memcpy(&report->target_address[1], data, data_length);
 465	return data_length + 6;
 466}
 467
 468static int cp2112_write_req(void *buf, u8 slave_address, u8 command, u8 *data,
 469			    u8 data_length)
 470{
 471	struct cp2112_write_req_report *report = buf;
 472
 473	if (data_length > sizeof(report->data) - 1)
 474		return -EINVAL;
 475
 476	report->report = CP2112_DATA_WRITE_REQUEST;
 477	report->slave_address = slave_address << 1;
 478	report->length = data_length + 1;
 479	report->data[0] = command;
 480	memcpy(&report->data[1], data, data_length);
 481	return data_length + 4;
 482}
 483
 484static int cp2112_i2c_write_req(void *buf, u8 slave_address, u8 *data,
 485				u8 data_length)
 486{
 487	struct cp2112_write_req_report *report = buf;
 488
 489	if (data_length > sizeof(report->data))
 490		return -EINVAL;
 491
 492	report->report = CP2112_DATA_WRITE_REQUEST;
 493	report->slave_address = slave_address << 1;
 494	report->length = data_length;
 495	memcpy(report->data, data, data_length);
 496	return data_length + 3;
 497}
 498
 499static int cp2112_i2c_write_read_req(void *buf, u8 slave_address,
 500				     u8 *addr, int addr_length,
 501				     int read_length)
 502{
 503	struct cp2112_write_read_req_report *report = buf;
 504
 505	if (read_length < 1 || read_length > 512 ||
 506	    addr_length > sizeof(report->target_address))
 507		return -EINVAL;
 508
 509	report->report = CP2112_DATA_WRITE_READ_REQUEST;
 510	report->slave_address = slave_address << 1;
 511	report->length = cpu_to_be16(read_length);
 512	report->target_address_length = addr_length;
 513	memcpy(report->target_address, addr, addr_length);
 514	return addr_length + 5;
 515}
 516
 517static int cp2112_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg *msgs,
 518			   int num)
 519{
 520	struct cp2112_device *dev = (struct cp2112_device *)adap->algo_data;
 521	struct hid_device *hdev = dev->hdev;
 522	u8 buf[64];
 523	ssize_t count;
 524	ssize_t read_length = 0;
 525	u8 *read_buf = NULL;
 526	unsigned int retries;
 527	int ret;
 528
 529	hid_dbg(hdev, "I2C %d messages\n", num);
 530
 531	if (num == 1) {
 532		if (msgs->flags & I2C_M_RD) {
 533			hid_dbg(hdev, "I2C read %#04x len %d\n",
 534				msgs->addr, msgs->len);
 535			read_length = msgs->len;
 536			read_buf = msgs->buf;
 537			count = cp2112_read_req(buf, msgs->addr, msgs->len);
 538		} else {
 539			hid_dbg(hdev, "I2C write %#04x len %d\n",
 540				msgs->addr, msgs->len);
 541			count = cp2112_i2c_write_req(buf, msgs->addr,
 542						     msgs->buf, msgs->len);
 543		}
 544		if (count < 0)
 545			return count;
 546	} else if (dev->hwversion > 1 &&  /* no repeated start in rev 1 */
 547		   num == 2 &&
 548		   msgs[0].addr == msgs[1].addr &&
 549		   !(msgs[0].flags & I2C_M_RD) && (msgs[1].flags & I2C_M_RD)) {
 550		hid_dbg(hdev, "I2C write-read %#04x wlen %d rlen %d\n",
 551			msgs[0].addr, msgs[0].len, msgs[1].len);
 552		read_length = msgs[1].len;
 553		read_buf = msgs[1].buf;
 554		count = cp2112_i2c_write_read_req(buf, msgs[0].addr,
 555				msgs[0].buf, msgs[0].len, msgs[1].len);
 556		if (count < 0)
 557			return count;
 558	} else {
 559		hid_err(hdev,
 560			"Multi-message I2C transactions not supported\n");
 561		return -EOPNOTSUPP;
 562	}
 563
 564	ret = hid_hw_power(hdev, PM_HINT_FULLON);
 565	if (ret < 0) {
 566		hid_err(hdev, "power management error: %d\n", ret);
 567		return ret;
 568	}
 569
 570	ret = cp2112_hid_output(hdev, buf, count, HID_OUTPUT_REPORT);
 571	if (ret < 0) {
 572		hid_warn(hdev, "Error starting transaction: %d\n", ret);
 573		goto power_normal;
 574	}
 575
 576	for (retries = 0; retries < XFER_STATUS_RETRIES; ++retries) {
 577		ret = cp2112_xfer_status(dev);
 578		if (-EBUSY == ret)
 579			continue;
 580		if (ret < 0)
 581			goto power_normal;
 582		break;
 583	}
 584
 585	if (XFER_STATUS_RETRIES <= retries) {
 586		hid_warn(hdev, "Transfer timed out, cancelling.\n");
 587		buf[0] = CP2112_CANCEL_TRANSFER;
 588		buf[1] = 0x01;
 589
 590		ret = cp2112_hid_output(hdev, buf, 2, HID_OUTPUT_REPORT);
 591		if (ret < 0)
 592			hid_warn(hdev, "Error cancelling transaction: %d\n",
 593				 ret);
 594
 595		ret = -ETIMEDOUT;
 596		goto power_normal;
 597	}
 598
 599	for (count = 0; count < read_length;) {
 600		ret = cp2112_read(dev, read_buf + count, read_length - count);
 601		if (ret < 0)
 602			goto power_normal;
 603		if (ret == 0) {
 604			hid_err(hdev, "read returned 0\n");
 605			ret = -EIO;
 606			goto power_normal;
 607		}
 608		count += ret;
 609		if (count > read_length) {
 610			/*
 611			 * The hardware returned too much data.
 612			 * This is mostly harmless because cp2112_read()
 613			 * has a limit check so didn't overrun our
 614			 * buffer.  Nevertheless, we return an error
 615			 * because something is seriously wrong and
 616			 * it shouldn't go unnoticed.
 617			 */
 618			hid_err(hdev, "long read: %d > %zd\n",
 619				ret, read_length - count + ret);
 620			ret = -EIO;
 621			goto power_normal;
 622		}
 623	}
 624
 625	/* return the number of transferred messages */
 626	ret = num;
 627
 628power_normal:
 629	hid_hw_power(hdev, PM_HINT_NORMAL);
 630	hid_dbg(hdev, "I2C transfer finished: %d\n", ret);
 631	return ret;
 632}
 633
 634static int cp2112_xfer(struct i2c_adapter *adap, u16 addr,
 635		       unsigned short flags, char read_write, u8 command,
 636		       int size, union i2c_smbus_data *data)
 637{
 638	struct cp2112_device *dev = (struct cp2112_device *)adap->algo_data;
 639	struct hid_device *hdev = dev->hdev;
 640	u8 buf[64];
 641	__le16 word;
 642	ssize_t count;
 643	size_t read_length = 0;
 644	unsigned int retries;
 645	int ret;
 646
 647	hid_dbg(hdev, "%s addr 0x%x flags 0x%x cmd 0x%x size %d\n",
 648		read_write == I2C_SMBUS_WRITE ? "write" : "read",
 649		addr, flags, command, size);
 650
 651	switch (size) {
 652	case I2C_SMBUS_BYTE:
 653		read_length = 1;
 654
 655		if (I2C_SMBUS_READ == read_write)
 656			count = cp2112_read_req(buf, addr, read_length);
 657		else
 658			count = cp2112_write_req(buf, addr, command, NULL,
 659						 0);
 660		break;
 661	case I2C_SMBUS_BYTE_DATA:
 662		read_length = 1;
 663
 664		if (I2C_SMBUS_READ == read_write)
 665			count = cp2112_write_read_req(buf, addr, read_length,
 666						      command, NULL, 0);
 667		else
 668			count = cp2112_write_req(buf, addr, command,
 669						 &data->byte, 1);
 670		break;
 671	case I2C_SMBUS_WORD_DATA:
 672		read_length = 2;
 673		word = cpu_to_le16(data->word);
 674
 675		if (I2C_SMBUS_READ == read_write)
 676			count = cp2112_write_read_req(buf, addr, read_length,
 677						      command, NULL, 0);
 678		else
 679			count = cp2112_write_req(buf, addr, command,
 680						 (u8 *)&word, 2);
 681		break;
 682	case I2C_SMBUS_PROC_CALL:
 683		size = I2C_SMBUS_WORD_DATA;
 684		read_write = I2C_SMBUS_READ;
 685		read_length = 2;
 686		word = cpu_to_le16(data->word);
 687
 688		count = cp2112_write_read_req(buf, addr, read_length, command,
 689					      (u8 *)&word, 2);
 690		break;
 691	case I2C_SMBUS_I2C_BLOCK_DATA:
 692		if (read_write == I2C_SMBUS_READ) {
 693			read_length = data->block[0];
 694			count = cp2112_write_read_req(buf, addr, read_length,
 695						      command, NULL, 0);
 696		} else {
 697			count = cp2112_write_req(buf, addr, command,
 698						 data->block + 1,
 699						 data->block[0]);
 700		}
 701		break;
 702	case I2C_SMBUS_BLOCK_DATA:
 703		if (I2C_SMBUS_READ == read_write) {
 704			count = cp2112_write_read_req(buf, addr,
 705						      I2C_SMBUS_BLOCK_MAX,
 706						      command, NULL, 0);
 707		} else {
 708			count = cp2112_write_req(buf, addr, command,
 709						 data->block,
 710						 data->block[0] + 1);
 711		}
 712		break;
 713	case I2C_SMBUS_BLOCK_PROC_CALL:
 714		size = I2C_SMBUS_BLOCK_DATA;
 715		read_write = I2C_SMBUS_READ;
 716
 717		count = cp2112_write_read_req(buf, addr, I2C_SMBUS_BLOCK_MAX,
 718					      command, data->block,
 719					      data->block[0] + 1);
 720		break;
 721	default:
 722		hid_warn(hdev, "Unsupported transaction %d\n", size);
 723		return -EOPNOTSUPP;
 724	}
 725
 726	if (count < 0)
 727		return count;
 728
 729	ret = hid_hw_power(hdev, PM_HINT_FULLON);
 730	if (ret < 0) {
 731		hid_err(hdev, "power management error: %d\n", ret);
 732		return ret;
 733	}
 734
 735	ret = cp2112_hid_output(hdev, buf, count, HID_OUTPUT_REPORT);
 736	if (ret < 0) {
 737		hid_warn(hdev, "Error starting transaction: %d\n", ret);
 738		goto power_normal;
 739	}
 740
 741	for (retries = 0; retries < XFER_STATUS_RETRIES; ++retries) {
 742		ret = cp2112_xfer_status(dev);
 743		if (-EBUSY == ret)
 744			continue;
 745		if (ret < 0)
 746			goto power_normal;
 747		break;
 748	}
 749
 750	if (XFER_STATUS_RETRIES <= retries) {
 751		hid_warn(hdev, "Transfer timed out, cancelling.\n");
 752		buf[0] = CP2112_CANCEL_TRANSFER;
 753		buf[1] = 0x01;
 754
 755		ret = cp2112_hid_output(hdev, buf, 2, HID_OUTPUT_REPORT);
 756		if (ret < 0)
 757			hid_warn(hdev, "Error cancelling transaction: %d\n",
 758				 ret);
 759
 760		ret = -ETIMEDOUT;
 761		goto power_normal;
 762	}
 763
 764	if (I2C_SMBUS_WRITE == read_write) {
 765		ret = 0;
 766		goto power_normal;
 767	}
 768
 769	if (I2C_SMBUS_BLOCK_DATA == size)
 770		read_length = ret;
 771
 772	ret = cp2112_read(dev, buf, read_length);
 773	if (ret < 0)
 774		goto power_normal;
 775	if (ret != read_length) {
 776		hid_warn(hdev, "short read: %d < %zd\n", ret, read_length);
 777		ret = -EIO;
 778		goto power_normal;
 779	}
 780
 781	switch (size) {
 782	case I2C_SMBUS_BYTE:
 783	case I2C_SMBUS_BYTE_DATA:
 784		data->byte = buf[0];
 785		break;
 786	case I2C_SMBUS_WORD_DATA:
 787		data->word = le16_to_cpup((__le16 *)buf);
 788		break;
 789	case I2C_SMBUS_I2C_BLOCK_DATA:
 790		memcpy(data->block + 1, buf, read_length);
 791		break;
 792	case I2C_SMBUS_BLOCK_DATA:
 793		if (read_length > I2C_SMBUS_BLOCK_MAX) {
 794			ret = -EPROTO;
 795			goto power_normal;
 796		}
 797
 798		memcpy(data->block, buf, read_length);
 799		break;
 800	}
 801
 802	ret = 0;
 803power_normal:
 804	hid_hw_power(hdev, PM_HINT_NORMAL);
 805	hid_dbg(hdev, "transfer finished: %d\n", ret);
 806	return ret;
 807}
 808
 809static u32 cp2112_functionality(struct i2c_adapter *adap)
 810{
 811	return I2C_FUNC_I2C |
 812		I2C_FUNC_SMBUS_BYTE |
 813		I2C_FUNC_SMBUS_BYTE_DATA |
 814		I2C_FUNC_SMBUS_WORD_DATA |
 815		I2C_FUNC_SMBUS_BLOCK_DATA |
 816		I2C_FUNC_SMBUS_I2C_BLOCK |
 817		I2C_FUNC_SMBUS_PROC_CALL |
 818		I2C_FUNC_SMBUS_BLOCK_PROC_CALL;
 819}
 820
 821static const struct i2c_algorithm smbus_algorithm = {
 822	.master_xfer	= cp2112_i2c_xfer,
 823	.smbus_xfer	= cp2112_xfer,
 824	.functionality	= cp2112_functionality,
 825};
 826
 827static int cp2112_get_usb_config(struct hid_device *hdev,
 828				 struct cp2112_usb_config_report *cfg)
 829{
 830	int ret;
 831
 832	ret = cp2112_hid_get(hdev, CP2112_USB_CONFIG, (u8 *)cfg, sizeof(*cfg),
 833			     HID_FEATURE_REPORT);
 834	if (ret != sizeof(*cfg)) {
 835		hid_err(hdev, "error reading usb config: %d\n", ret);
 836		if (ret < 0)
 837			return ret;
 838		return -EIO;
 839	}
 840
 841	return 0;
 842}
 843
 844static int cp2112_set_usb_config(struct hid_device *hdev,
 845				 struct cp2112_usb_config_report *cfg)
 846{
 847	int ret;
 848
 849	BUG_ON(cfg->report != CP2112_USB_CONFIG);
 850
 851	ret = cp2112_hid_output(hdev, (u8 *)cfg, sizeof(*cfg),
 852				HID_FEATURE_REPORT);
 853	if (ret != sizeof(*cfg)) {
 854		hid_err(hdev, "error writing usb config: %d\n", ret);
 855		if (ret < 0)
 856			return ret;
 857		return -EIO;
 858	}
 859
 860	return 0;
 861}
 862
 863static void chmod_sysfs_attrs(struct hid_device *hdev);
 864
 865#define CP2112_CONFIG_ATTR(name, store, format, ...) \
 866static ssize_t name##_store(struct device *kdev, \
 867			    struct device_attribute *attr, const char *buf, \
 868			    size_t count) \
 869{ \
 870	struct hid_device *hdev = to_hid_device(kdev); \
 871	struct cp2112_usb_config_report cfg; \
 872	int ret = cp2112_get_usb_config(hdev, &cfg); \
 873	if (ret) \
 874		return ret; \
 875	store; \
 876	ret = cp2112_set_usb_config(hdev, &cfg); \
 877	if (ret) \
 878		return ret; \
 879	chmod_sysfs_attrs(hdev); \
 880	return count; \
 881} \
 882static ssize_t name##_show(struct device *kdev, \
 883			   struct device_attribute *attr, char *buf) \
 884{ \
 885	struct hid_device *hdev = to_hid_device(kdev); \
 886	struct cp2112_usb_config_report cfg; \
 887	int ret = cp2112_get_usb_config(hdev, &cfg); \
 888	if (ret) \
 889		return ret; \
 890	return scnprintf(buf, PAGE_SIZE, format, ##__VA_ARGS__); \
 891} \
 892static DEVICE_ATTR_RW(name);
 893
 894CP2112_CONFIG_ATTR(vendor_id, ({
 895	u16 vid;
 896
 897	if (sscanf(buf, "%hi", &vid) != 1)
 898		return -EINVAL;
 899
 900	cfg.vid = cpu_to_le16(vid);
 901	cfg.mask = 0x01;
 902}), "0x%04x\n", le16_to_cpu(cfg.vid));
 903
 904CP2112_CONFIG_ATTR(product_id, ({
 905	u16 pid;
 906
 907	if (sscanf(buf, "%hi", &pid) != 1)
 908		return -EINVAL;
 909
 910	cfg.pid = cpu_to_le16(pid);
 911	cfg.mask = 0x02;
 912}), "0x%04x\n", le16_to_cpu(cfg.pid));
 913
 914CP2112_CONFIG_ATTR(max_power, ({
 915	int mA;
 916
 917	if (sscanf(buf, "%i", &mA) != 1)
 918		return -EINVAL;
 919
 920	cfg.max_power = (mA + 1) / 2;
 921	cfg.mask = 0x04;
 922}), "%u mA\n", cfg.max_power * 2);
 923
 924CP2112_CONFIG_ATTR(power_mode, ({
 925	if (sscanf(buf, "%hhi", &cfg.power_mode) != 1)
 926		return -EINVAL;
 927
 928	cfg.mask = 0x08;
 929}), "%u\n", cfg.power_mode);
 930
 931CP2112_CONFIG_ATTR(release_version, ({
 932	if (sscanf(buf, "%hhi.%hhi", &cfg.release_major, &cfg.release_minor)
 933	    != 2)
 934		return -EINVAL;
 935
 936	cfg.mask = 0x10;
 937}), "%u.%u\n", cfg.release_major, cfg.release_minor);
 938
 939#undef CP2112_CONFIG_ATTR
 940
 941struct cp2112_pstring_attribute {
 942	struct device_attribute attr;
 943	unsigned char report;
 944};
 945
 946static ssize_t pstr_store(struct device *kdev,
 947			  struct device_attribute *kattr, const char *buf,
 948			  size_t count)
 949{
 950	struct hid_device *hdev = to_hid_device(kdev);
 951	struct cp2112_pstring_attribute *attr =
 952		container_of(kattr, struct cp2112_pstring_attribute, attr);
 953	struct cp2112_string_report report;
 954	int ret;
 955
 956	memset(&report, 0, sizeof(report));
 957
 958	ret = utf8s_to_utf16s(buf, count, UTF16_LITTLE_ENDIAN,
 959			      report.string, ARRAY_SIZE(report.string));
 960	report.report = attr->report;
 961	report.length = ret * sizeof(report.string[0]) + 2;
 962	report.type = USB_DT_STRING;
 963
 964	ret = cp2112_hid_output(hdev, &report.report, report.length + 1,
 965				HID_FEATURE_REPORT);
 966	if (ret != report.length + 1) {
 967		hid_err(hdev, "error writing %s string: %d\n", kattr->attr.name,
 968			ret);
 969		if (ret < 0)
 970			return ret;
 971		return -EIO;
 972	}
 973
 974	chmod_sysfs_attrs(hdev);
 975	return count;
 976}
 977
 978static ssize_t pstr_show(struct device *kdev,
 979			 struct device_attribute *kattr, char *buf)
 980{
 981	struct hid_device *hdev = to_hid_device(kdev);
 982	struct cp2112_pstring_attribute *attr =
 983		container_of(kattr, struct cp2112_pstring_attribute, attr);
 984	struct cp2112_string_report report;
 985	u8 length;
 986	int ret;
 987
 988	ret = cp2112_hid_get(hdev, attr->report, &report.report,
 989			     sizeof(report) - 1, HID_FEATURE_REPORT);
 990	if (ret < 3) {
 991		hid_err(hdev, "error reading %s string: %d\n", kattr->attr.name,
 992			ret);
 993		if (ret < 0)
 994			return ret;
 995		return -EIO;
 996	}
 997
 998	if (report.length < 2) {
 999		hid_err(hdev, "invalid %s string length: %d\n",
1000			kattr->attr.name, report.length);
1001		return -EIO;
1002	}
1003
1004	length = report.length > ret - 1 ? ret - 1 : report.length;
1005	length = (length - 2) / sizeof(report.string[0]);
1006	ret = utf16s_to_utf8s(report.string, length, UTF16_LITTLE_ENDIAN, buf,
1007			      PAGE_SIZE - 1);
1008	buf[ret++] = '\n';
1009	return ret;
1010}
1011
1012#define CP2112_PSTR_ATTR(name, _report) \
1013static struct cp2112_pstring_attribute dev_attr_##name = { \
1014	.attr = __ATTR(name, (S_IWUSR | S_IRUGO), pstr_show, pstr_store), \
1015	.report = _report, \
1016};
1017
1018CP2112_PSTR_ATTR(manufacturer,	CP2112_MANUFACTURER_STRING);
1019CP2112_PSTR_ATTR(product,	CP2112_PRODUCT_STRING);
1020CP2112_PSTR_ATTR(serial,	CP2112_SERIAL_STRING);
1021
1022#undef CP2112_PSTR_ATTR
1023
1024static const struct attribute_group cp2112_attr_group = {
1025	.attrs = (struct attribute *[]){
1026		&dev_attr_vendor_id.attr,
1027		&dev_attr_product_id.attr,
1028		&dev_attr_max_power.attr,
1029		&dev_attr_power_mode.attr,
1030		&dev_attr_release_version.attr,
1031		&dev_attr_manufacturer.attr.attr,
1032		&dev_attr_product.attr.attr,
1033		&dev_attr_serial.attr.attr,
1034		NULL
1035	}
1036};
1037
1038/* Chmoding our sysfs attributes is simply a way to expose which fields in the
1039 * PROM have already been programmed. We do not depend on this preventing
1040 * writing to these attributes since the CP2112 will simply ignore writes to
1041 * already-programmed fields. This is why there is no sense in fixing this
1042 * racy behaviour.
1043 */
1044static void chmod_sysfs_attrs(struct hid_device *hdev)
1045{
1046	struct attribute **attr;
1047	u8 buf[2];
1048	int ret;
1049
1050	ret = cp2112_hid_get(hdev, CP2112_LOCK_BYTE, buf, sizeof(buf),
1051			     HID_FEATURE_REPORT);
1052	if (ret != sizeof(buf)) {
1053		hid_err(hdev, "error reading lock byte: %d\n", ret);
1054		return;
1055	}
1056
1057	for (attr = cp2112_attr_group.attrs; *attr; ++attr) {
1058		umode_t mode = (buf[1] & 1) ? S_IWUSR | S_IRUGO : S_IRUGO;
1059		ret = sysfs_chmod_file(&hdev->dev.kobj, *attr, mode);
1060		if (ret < 0)
1061			hid_err(hdev, "error chmoding sysfs file %s\n",
1062				(*attr)->name);
1063		buf[1] >>= 1;
1064	}
1065}
1066
1067static void cp2112_gpio_irq_ack(struct irq_data *d)
1068{
1069}
1070
1071static void cp2112_gpio_irq_mask(struct irq_data *d)
1072{
1073	struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
1074	struct cp2112_device *dev = gpiochip_get_data(gc);
1075
1076	__clear_bit(d->hwirq, &dev->irq_mask);
1077}
1078
1079static void cp2112_gpio_irq_unmask(struct irq_data *d)
1080{
1081	struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
1082	struct cp2112_device *dev = gpiochip_get_data(gc);
1083
1084	__set_bit(d->hwirq, &dev->irq_mask);
1085}
1086
1087static void cp2112_gpio_poll_callback(struct work_struct *work)
1088{
1089	struct cp2112_device *dev = container_of(work, struct cp2112_device,
1090						 gpio_poll_worker.work);
1091	struct irq_data *d;
1092	u8 gpio_mask;
1093	u8 virqs = (u8)dev->irq_mask;
1094	u32 irq_type;
1095	int irq, virq, ret;
1096
1097	ret = cp2112_gpio_get_all(&dev->gc);
1098	if (ret == -ENODEV) /* the hardware has been disconnected */
1099		return;
1100	if (ret < 0)
1101		goto exit;
1102
1103	gpio_mask = ret;
1104
1105	while (virqs) {
1106		virq = ffs(virqs) - 1;
1107		virqs &= ~BIT(virq);
1108
1109		if (!dev->gc.to_irq)
1110			break;
1111
1112		irq = dev->gc.to_irq(&dev->gc, virq);
1113
1114		d = irq_get_irq_data(irq);
1115		if (!d)
1116			continue;
1117
1118		irq_type = irqd_get_trigger_type(d);
1119
1120		if (gpio_mask & BIT(virq)) {
1121			/* Level High */
1122
1123			if (irq_type & IRQ_TYPE_LEVEL_HIGH)
1124				handle_nested_irq(irq);
1125
1126			if ((irq_type & IRQ_TYPE_EDGE_RISING) &&
1127			    !(dev->gpio_prev_state & BIT(virq)))
1128				handle_nested_irq(irq);
1129		} else {
1130			/* Level Low */
1131
1132			if (irq_type & IRQ_TYPE_LEVEL_LOW)
1133				handle_nested_irq(irq);
1134
1135			if ((irq_type & IRQ_TYPE_EDGE_FALLING) &&
1136			    (dev->gpio_prev_state & BIT(virq)))
1137				handle_nested_irq(irq);
1138		}
1139	}
1140
1141	dev->gpio_prev_state = gpio_mask;
1142
1143exit:
1144	if (dev->gpio_poll)
1145		schedule_delayed_work(&dev->gpio_poll_worker, 10);
1146}
1147
1148
1149static unsigned int cp2112_gpio_irq_startup(struct irq_data *d)
1150{
1151	struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
1152	struct cp2112_device *dev = gpiochip_get_data(gc);
1153
1154	INIT_DELAYED_WORK(&dev->gpio_poll_worker, cp2112_gpio_poll_callback);
1155
1156	if (!dev->gpio_poll) {
1157		dev->gpio_poll = true;
1158		schedule_delayed_work(&dev->gpio_poll_worker, 0);
1159	}
1160
1161	cp2112_gpio_irq_unmask(d);
1162	return 0;
1163}
1164
1165static void cp2112_gpio_irq_shutdown(struct irq_data *d)
1166{
1167	struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
1168	struct cp2112_device *dev = gpiochip_get_data(gc);
1169
1170	cancel_delayed_work_sync(&dev->gpio_poll_worker);
1171}
1172
1173static int cp2112_gpio_irq_type(struct irq_data *d, unsigned int type)
1174{
1175	return 0;
1176}
1177
1178static struct irq_chip cp2112_gpio_irqchip = {
1179	.name = "cp2112-gpio",
1180	.irq_startup = cp2112_gpio_irq_startup,
1181	.irq_shutdown = cp2112_gpio_irq_shutdown,
1182	.irq_ack = cp2112_gpio_irq_ack,
1183	.irq_mask = cp2112_gpio_irq_mask,
1184	.irq_unmask = cp2112_gpio_irq_unmask,
1185	.irq_set_type = cp2112_gpio_irq_type,
1186};
1187
1188static int __maybe_unused cp2112_allocate_irq(struct cp2112_device *dev,
1189					      int pin)
1190{
1191	int ret;
1192
1193	if (dev->desc[pin])
1194		return -EINVAL;
1195
1196	dev->desc[pin] = gpiochip_request_own_desc(&dev->gc, pin,
1197						   "HID/I2C:Event",
1198						   GPIO_ACTIVE_HIGH,
1199						   GPIOD_IN);
1200	if (IS_ERR(dev->desc[pin])) {
1201		dev_err(dev->gc.parent, "Failed to request GPIO\n");
1202		return PTR_ERR(dev->desc[pin]);
1203	}
1204
1205	ret = cp2112_gpio_direction_input(&dev->gc, pin);
1206	if (ret < 0) {
1207		dev_err(dev->gc.parent, "Failed to set GPIO to input dir\n");
1208		goto err_desc;
1209	}
1210
1211	ret = gpiochip_lock_as_irq(&dev->gc, pin);
1212	if (ret) {
1213		dev_err(dev->gc.parent, "Failed to lock GPIO as interrupt\n");
1214		goto err_desc;
1215	}
1216
1217	ret = gpiod_to_irq(dev->desc[pin]);
1218	if (ret < 0) {
1219		dev_err(dev->gc.parent, "Failed to translate GPIO to IRQ\n");
1220		goto err_lock;
1221	}
1222
1223	return ret;
1224
1225err_lock:
1226	gpiochip_unlock_as_irq(&dev->gc, pin);
1227err_desc:
1228	gpiochip_free_own_desc(dev->desc[pin]);
1229	dev->desc[pin] = NULL;
1230	return ret;
1231}
1232
1233static int cp2112_probe(struct hid_device *hdev, const struct hid_device_id *id)
1234{
1235	struct cp2112_device *dev;
1236	u8 buf[3];
1237	struct cp2112_smbus_config_report config;
1238	int ret;
1239
1240	dev = devm_kzalloc(&hdev->dev, sizeof(*dev), GFP_KERNEL);
1241	if (!dev)
1242		return -ENOMEM;
1243
1244	dev->in_out_buffer = devm_kzalloc(&hdev->dev, CP2112_REPORT_MAX_LENGTH,
1245					  GFP_KERNEL);
1246	if (!dev->in_out_buffer)
1247		return -ENOMEM;
1248
1249	mutex_init(&dev->lock);
1250
1251	ret = hid_parse(hdev);
1252	if (ret) {
1253		hid_err(hdev, "parse failed\n");
1254		return ret;
1255	}
1256
1257	ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW);
1258	if (ret) {
1259		hid_err(hdev, "hw start failed\n");
1260		return ret;
1261	}
1262
1263	ret = hid_hw_open(hdev);
1264	if (ret) {
1265		hid_err(hdev, "hw open failed\n");
1266		goto err_hid_stop;
1267	}
1268
1269	ret = hid_hw_power(hdev, PM_HINT_FULLON);
1270	if (ret < 0) {
1271		hid_err(hdev, "power management error: %d\n", ret);
1272		goto err_hid_close;
1273	}
1274
1275	ret = cp2112_hid_get(hdev, CP2112_GET_VERSION_INFO, buf, sizeof(buf),
1276			     HID_FEATURE_REPORT);
1277	if (ret != sizeof(buf)) {
1278		hid_err(hdev, "error requesting version\n");
1279		if (ret >= 0)
1280			ret = -EIO;
1281		goto err_power_normal;
1282	}
1283
1284	hid_info(hdev, "Part Number: 0x%02X Device Version: 0x%02X\n",
1285		 buf[1], buf[2]);
1286
1287	ret = cp2112_hid_get(hdev, CP2112_SMBUS_CONFIG, (u8 *)&config,
1288			     sizeof(config), HID_FEATURE_REPORT);
1289	if (ret != sizeof(config)) {
1290		hid_err(hdev, "error requesting SMBus config\n");
1291		if (ret >= 0)
1292			ret = -EIO;
1293		goto err_power_normal;
1294	}
1295
1296	config.retry_time = cpu_to_be16(1);
1297
1298	ret = cp2112_hid_output(hdev, (u8 *)&config, sizeof(config),
1299				HID_FEATURE_REPORT);
1300	if (ret != sizeof(config)) {
1301		hid_err(hdev, "error setting SMBus config\n");
1302		if (ret >= 0)
1303			ret = -EIO;
1304		goto err_power_normal;
1305	}
1306
1307	hid_set_drvdata(hdev, (void *)dev);
1308	dev->hdev		= hdev;
1309	dev->adap.owner		= THIS_MODULE;
1310	dev->adap.class		= I2C_CLASS_HWMON;
1311	dev->adap.algo		= &smbus_algorithm;
1312	dev->adap.algo_data	= dev;
1313	dev->adap.dev.parent	= &hdev->dev;
1314	snprintf(dev->adap.name, sizeof(dev->adap.name),
1315		 "CP2112 SMBus Bridge on hidraw%d",
1316		 ((struct hidraw *)hdev->hidraw)->minor);
1317	dev->hwversion = buf[2];
1318	init_waitqueue_head(&dev->wait);
1319
1320	hid_device_io_start(hdev);
1321	ret = i2c_add_adapter(&dev->adap);
1322	hid_device_io_stop(hdev);
1323
1324	if (ret) {
1325		hid_err(hdev, "error registering i2c adapter\n");
1326		goto err_power_normal;
1327	}
1328
1329	hid_dbg(hdev, "adapter registered\n");
1330
1331	dev->gc.label			= "cp2112_gpio";
1332	dev->gc.direction_input		= cp2112_gpio_direction_input;
1333	dev->gc.direction_output	= cp2112_gpio_direction_output;
1334	dev->gc.set			= cp2112_gpio_set;
1335	dev->gc.get			= cp2112_gpio_get;
1336	dev->gc.base			= -1;
1337	dev->gc.ngpio			= 8;
1338	dev->gc.can_sleep		= 1;
1339	dev->gc.parent			= &hdev->dev;
1340
1341	ret = gpiochip_add_data(&dev->gc, dev);
1342	if (ret < 0) {
1343		hid_err(hdev, "error registering gpio chip\n");
1344		goto err_free_i2c;
1345	}
1346
1347	ret = sysfs_create_group(&hdev->dev.kobj, &cp2112_attr_group);
1348	if (ret < 0) {
1349		hid_err(hdev, "error creating sysfs attrs\n");
1350		goto err_gpiochip_remove;
1351	}
1352
1353	chmod_sysfs_attrs(hdev);
1354	hid_hw_power(hdev, PM_HINT_NORMAL);
1355
1356	ret = gpiochip_irqchip_add(&dev->gc, &cp2112_gpio_irqchip, 0,
1357				   handle_simple_irq, IRQ_TYPE_NONE);
1358	if (ret) {
1359		dev_err(dev->gc.parent, "failed to add IRQ chip\n");
1360		goto err_sysfs_remove;
1361	}
1362
1363	return ret;
1364
1365err_sysfs_remove:
1366	sysfs_remove_group(&hdev->dev.kobj, &cp2112_attr_group);
1367err_gpiochip_remove:
1368	gpiochip_remove(&dev->gc);
1369err_free_i2c:
1370	i2c_del_adapter(&dev->adap);
1371err_power_normal:
1372	hid_hw_power(hdev, PM_HINT_NORMAL);
1373err_hid_close:
1374	hid_hw_close(hdev);
1375err_hid_stop:
1376	hid_hw_stop(hdev);
1377	return ret;
1378}
1379
1380static void cp2112_remove(struct hid_device *hdev)
1381{
1382	struct cp2112_device *dev = hid_get_drvdata(hdev);
1383	int i;
1384
1385	sysfs_remove_group(&hdev->dev.kobj, &cp2112_attr_group);
1386	i2c_del_adapter(&dev->adap);
1387
1388	if (dev->gpio_poll) {
1389		dev->gpio_poll = false;
1390		cancel_delayed_work_sync(&dev->gpio_poll_worker);
1391	}
1392
1393	for (i = 0; i < ARRAY_SIZE(dev->desc); i++) {
1394		gpiochip_unlock_as_irq(&dev->gc, i);
1395		gpiochip_free_own_desc(dev->desc[i]);
1396	}
1397
1398	gpiochip_remove(&dev->gc);
1399	/* i2c_del_adapter has finished removing all i2c devices from our
1400	 * adapter. Well behaved devices should no longer call our cp2112_xfer
1401	 * and should have waited for any pending calls to finish. It has also
1402	 * waited for device_unregister(&adap->dev) to complete. Therefore we
1403	 * can safely free our struct cp2112_device.
1404	 */
1405	hid_hw_close(hdev);
1406	hid_hw_stop(hdev);
1407}
1408
1409static int cp2112_raw_event(struct hid_device *hdev, struct hid_report *report,
1410			    u8 *data, int size)
1411{
1412	struct cp2112_device *dev = hid_get_drvdata(hdev);
1413	struct cp2112_xfer_status_report *xfer = (void *)data;
1414
1415	switch (data[0]) {
1416	case CP2112_TRANSFER_STATUS_RESPONSE:
1417		hid_dbg(hdev, "xfer status: %02x %02x %04x %04x\n",
1418			xfer->status0, xfer->status1,
1419			be16_to_cpu(xfer->retries), be16_to_cpu(xfer->length));
1420
1421		switch (xfer->status0) {
1422		case STATUS0_IDLE:
1423			dev->xfer_status = -EAGAIN;
1424			break;
1425		case STATUS0_BUSY:
1426			dev->xfer_status = -EBUSY;
1427			break;
1428		case STATUS0_COMPLETE:
1429			dev->xfer_status = be16_to_cpu(xfer->length);
1430			break;
1431		case STATUS0_ERROR:
1432			switch (xfer->status1) {
1433			case STATUS1_TIMEOUT_NACK:
1434			case STATUS1_TIMEOUT_BUS:
1435				dev->xfer_status = -ETIMEDOUT;
1436				break;
1437			default:
1438				dev->xfer_status = -EIO;
1439				break;
1440			}
1441			break;
1442		default:
1443			dev->xfer_status = -EINVAL;
1444			break;
1445		}
1446
1447		atomic_set(&dev->xfer_avail, 1);
1448		break;
1449	case CP2112_DATA_READ_RESPONSE:
1450		hid_dbg(hdev, "read response: %02x %02x\n", data[1], data[2]);
1451
1452		dev->read_length = data[2];
1453		if (dev->read_length > sizeof(dev->read_data))
1454			dev->read_length = sizeof(dev->read_data);
1455
1456		memcpy(dev->read_data, &data[3], dev->read_length);
1457		atomic_set(&dev->read_avail, 1);
1458		break;
1459	default:
1460		hid_err(hdev, "unknown report\n");
1461
1462		return 0;
1463	}
1464
1465	wake_up_interruptible(&dev->wait);
1466	return 1;
1467}
1468
1469static struct hid_driver cp2112_driver = {
1470	.name		= "cp2112",
1471	.id_table	= cp2112_devices,
1472	.probe		= cp2112_probe,
1473	.remove		= cp2112_remove,
1474	.raw_event	= cp2112_raw_event,
1475};
1476
1477module_hid_driver(cp2112_driver);
1478MODULE_DESCRIPTION("Silicon Labs HID USB to SMBus master bridge");
1479MODULE_AUTHOR("David Barksdale <dbarksdale@uplogix.com>");
1480MODULE_LICENSE("GPL");
1481