xref: /linux/drivers/hid/hid-mcp2221.c (revision a1ff5a7d78a036d6c2178ee5acd6ba4946243800)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * MCP2221A - Microchip USB to I2C Host Protocol Bridge
4  *
5  * Copyright (c) 2020, Rishi Gupta <gupt21@gmail.com>
6  *
7  * Datasheet: https://ww1.microchip.com/downloads/en/DeviceDoc/20005565B.pdf
8  */
9 
10 #include <linux/module.h>
11 #include <linux/err.h>
12 #include <linux/mutex.h>
13 #include <linux/bitfield.h>
14 #include <linux/completion.h>
15 #include <linux/delay.h>
16 #include <linux/hid.h>
17 #include <linux/hidraw.h>
18 #include <linux/i2c.h>
19 #include <linux/gpio/driver.h>
20 #include <linux/iio/iio.h>
21 #include "hid-ids.h"
22 
23 /* Commands codes in a raw output report */
24 enum {
25 	MCP2221_I2C_WR_DATA = 0x90,
26 	MCP2221_I2C_WR_NO_STOP = 0x94,
27 	MCP2221_I2C_RD_DATA = 0x91,
28 	MCP2221_I2C_RD_RPT_START = 0x93,
29 	MCP2221_I2C_GET_DATA = 0x40,
30 	MCP2221_I2C_PARAM_OR_STATUS	= 0x10,
31 	MCP2221_I2C_SET_SPEED = 0x20,
32 	MCP2221_I2C_CANCEL = 0x10,
33 	MCP2221_GPIO_SET = 0x50,
34 	MCP2221_GPIO_GET = 0x51,
35 	MCP2221_SET_SRAM_SETTINGS = 0x60,
36 	MCP2221_GET_SRAM_SETTINGS = 0x61,
37 	MCP2221_READ_FLASH_DATA = 0xb0,
38 };
39 
40 /* Response codes in a raw input report */
41 enum {
42 	MCP2221_SUCCESS = 0x00,
43 	MCP2221_I2C_ENG_BUSY = 0x01,
44 	MCP2221_I2C_START_TOUT = 0x12,
45 	MCP2221_I2C_STOP_TOUT = 0x62,
46 	MCP2221_I2C_WRADDRL_TOUT = 0x23,
47 	MCP2221_I2C_WRDATA_TOUT = 0x44,
48 	MCP2221_I2C_WRADDRL_NACK = 0x25,
49 	MCP2221_I2C_MASK_ADDR_NACK = 0x40,
50 	MCP2221_I2C_WRADDRL_SEND = 0x21,
51 	MCP2221_I2C_ADDR_NACK = 0x25,
52 	MCP2221_I2C_READ_PARTIAL = 0x54,
53 	MCP2221_I2C_READ_COMPL = 0x55,
54 	MCP2221_ALT_F_NOT_GPIOV = 0xEE,
55 	MCP2221_ALT_F_NOT_GPIOD = 0xEF,
56 };
57 
58 /* MCP GPIO direction encoding */
59 enum {
60 	MCP2221_DIR_OUT = 0x00,
61 	MCP2221_DIR_IN = 0x01,
62 };
63 
64 #define MCP_NGPIO	4
65 
66 /* MCP GPIO set command layout */
67 struct mcp_set_gpio {
68 	u8 cmd;
69 	u8 dummy;
70 	struct {
71 		u8 change_value;
72 		u8 value;
73 		u8 change_direction;
74 		u8 direction;
75 	} gpio[MCP_NGPIO];
76 } __packed;
77 
78 /* MCP GPIO get command layout */
79 struct mcp_get_gpio {
80 	u8 cmd;
81 	u8 dummy;
82 	struct {
83 		u8 value;
84 		u8 direction;
85 	} gpio[MCP_NGPIO];
86 } __packed;
87 
88 /*
89  * There is no way to distinguish responses. Therefore next command
90  * is sent only after response to previous has been received. Mutex
91  * lock is used for this purpose mainly.
92  */
93 struct mcp2221 {
94 	struct hid_device *hdev;
95 	struct i2c_adapter adapter;
96 	struct mutex lock;
97 	struct completion wait_in_report;
98 	struct delayed_work init_work;
99 	u8 *rxbuf;
100 	u8 txbuf[64];
101 	int rxbuf_idx;
102 	int status;
103 	u8 cur_i2c_clk_div;
104 	struct gpio_chip *gc;
105 	u8 gp_idx;
106 	u8 gpio_dir;
107 	u8 mode[4];
108 #if IS_REACHABLE(CONFIG_IIO)
109 	struct iio_chan_spec iio_channels[3];
110 	u16 adc_values[3];
111 	u8 adc_scale;
112 	u8 dac_value;
113 	u16 dac_scale;
114 #endif
115 };
116 
117 struct mcp2221_iio {
118 	struct mcp2221 *mcp;
119 };
120 
121 /*
122  * Default i2c bus clock frequency 400 kHz. Modify this if you
123  * want to set some other frequency (min 50 kHz - max 400 kHz).
124  */
125 static uint i2c_clk_freq = 400;
126 
127 /* Synchronously send output report to the device */
mcp_send_report(struct mcp2221 * mcp,u8 * out_report,size_t len)128 static int mcp_send_report(struct mcp2221 *mcp,
129 					u8 *out_report, size_t len)
130 {
131 	u8 *buf;
132 	int ret;
133 
134 	buf = kmemdup(out_report, len, GFP_KERNEL);
135 	if (!buf)
136 		return -ENOMEM;
137 
138 	/* mcp2221 uses interrupt endpoint for out reports */
139 	ret = hid_hw_output_report(mcp->hdev, buf, len);
140 	kfree(buf);
141 
142 	if (ret < 0)
143 		return ret;
144 	return 0;
145 }
146 
147 /*
148  * Send o/p report to the device and wait for i/p report to be
149  * received from the device. If the device does not respond,
150  * we timeout.
151  */
mcp_send_data_req_status(struct mcp2221 * mcp,u8 * out_report,int len)152 static int mcp_send_data_req_status(struct mcp2221 *mcp,
153 			u8 *out_report, int len)
154 {
155 	int ret;
156 	unsigned long t;
157 
158 	reinit_completion(&mcp->wait_in_report);
159 
160 	ret = mcp_send_report(mcp, out_report, len);
161 	if (ret)
162 		return ret;
163 
164 	t = wait_for_completion_timeout(&mcp->wait_in_report,
165 							msecs_to_jiffies(4000));
166 	if (!t)
167 		return -ETIMEDOUT;
168 
169 	return mcp->status;
170 }
171 
172 /* Check pass/fail for actual communication with i2c slave */
mcp_chk_last_cmd_status(struct mcp2221 * mcp)173 static int mcp_chk_last_cmd_status(struct mcp2221 *mcp)
174 {
175 	memset(mcp->txbuf, 0, 8);
176 	mcp->txbuf[0] = MCP2221_I2C_PARAM_OR_STATUS;
177 
178 	return mcp_send_data_req_status(mcp, mcp->txbuf, 8);
179 }
180 
181 /* Cancels last command releasing i2c bus just in case occupied */
mcp_cancel_last_cmd(struct mcp2221 * mcp)182 static int mcp_cancel_last_cmd(struct mcp2221 *mcp)
183 {
184 	memset(mcp->txbuf, 0, 8);
185 	mcp->txbuf[0] = MCP2221_I2C_PARAM_OR_STATUS;
186 	mcp->txbuf[2] = MCP2221_I2C_CANCEL;
187 
188 	return mcp_send_data_req_status(mcp, mcp->txbuf, 8);
189 }
190 
191 /* Check if the last command succeeded or failed and return the result.
192  * If the command did fail, cancel that command which will free the i2c bus.
193  */
mcp_chk_last_cmd_status_free_bus(struct mcp2221 * mcp)194 static int mcp_chk_last_cmd_status_free_bus(struct mcp2221 *mcp)
195 {
196 	int ret;
197 
198 	ret = mcp_chk_last_cmd_status(mcp);
199 	if (ret) {
200 		/* The last command was a failure.
201 		 * Send a cancel which will also free the bus.
202 		 */
203 		usleep_range(980, 1000);
204 		mcp_cancel_last_cmd(mcp);
205 	}
206 
207 	return ret;
208 }
209 
mcp_set_i2c_speed(struct mcp2221 * mcp)210 static int mcp_set_i2c_speed(struct mcp2221 *mcp)
211 {
212 	int ret;
213 
214 	memset(mcp->txbuf, 0, 8);
215 	mcp->txbuf[0] = MCP2221_I2C_PARAM_OR_STATUS;
216 	mcp->txbuf[3] = MCP2221_I2C_SET_SPEED;
217 	mcp->txbuf[4] = mcp->cur_i2c_clk_div;
218 
219 	ret = mcp_send_data_req_status(mcp, mcp->txbuf, 8);
220 	if (ret) {
221 		/* Small delay is needed here */
222 		usleep_range(980, 1000);
223 		mcp_cancel_last_cmd(mcp);
224 	}
225 
226 	return 0;
227 }
228 
229 /*
230  * An output report can contain minimum 1 and maximum 60 user data
231  * bytes. If the number of data bytes is more then 60, we send it
232  * in chunks of 60 bytes. Last chunk may contain exactly 60 or less
233  * bytes. Total number of bytes is informed in very first report to
234  * mcp2221, from that point onwards it first collect all the data
235  * from host and then send to i2c slave device.
236  */
mcp_i2c_write(struct mcp2221 * mcp,struct i2c_msg * msg,int type,u8 last_status)237 static int mcp_i2c_write(struct mcp2221 *mcp,
238 				struct i2c_msg *msg, int type, u8 last_status)
239 {
240 	int ret, len, idx, sent;
241 
242 	idx = 0;
243 	sent  = 0;
244 	if (msg->len < 60)
245 		len = msg->len;
246 	else
247 		len = 60;
248 
249 	do {
250 		mcp->txbuf[0] = type;
251 		mcp->txbuf[1] = msg->len & 0xff;
252 		mcp->txbuf[2] = msg->len >> 8;
253 		mcp->txbuf[3] = (u8)(msg->addr << 1);
254 
255 		memcpy(&mcp->txbuf[4], &msg->buf[idx], len);
256 
257 		ret = mcp_send_data_req_status(mcp, mcp->txbuf, len + 4);
258 		if (ret)
259 			return ret;
260 
261 		usleep_range(980, 1000);
262 
263 		if (last_status) {
264 			ret = mcp_chk_last_cmd_status_free_bus(mcp);
265 			if (ret)
266 				return ret;
267 		}
268 
269 		sent = sent + len;
270 		if (sent >= msg->len)
271 			break;
272 
273 		idx = idx + len;
274 		if ((msg->len - sent) < 60)
275 			len = msg->len - sent;
276 		else
277 			len = 60;
278 
279 		/*
280 		 * Testing shows delay is needed between successive writes
281 		 * otherwise next write fails on first-try from i2c core.
282 		 * This value is obtained through automated stress testing.
283 		 */
284 		usleep_range(980, 1000);
285 	} while (len > 0);
286 
287 	return ret;
288 }
289 
290 /*
291  * Device reads all data (0 - 65535 bytes) from i2c slave device and
292  * stores it in device itself. This data is read back from device to
293  * host in multiples of 60 bytes using input reports.
294  */
mcp_i2c_smbus_read(struct mcp2221 * mcp,struct i2c_msg * msg,int type,u16 smbus_addr,u8 smbus_len,u8 * smbus_buf)295 static int mcp_i2c_smbus_read(struct mcp2221 *mcp,
296 				struct i2c_msg *msg, int type, u16 smbus_addr,
297 				u8 smbus_len, u8 *smbus_buf)
298 {
299 	int ret;
300 	u16 total_len;
301 	int retries = 0;
302 
303 	mcp->txbuf[0] = type;
304 	if (msg) {
305 		mcp->txbuf[1] = msg->len & 0xff;
306 		mcp->txbuf[2] = msg->len >> 8;
307 		mcp->txbuf[3] = (u8)(msg->addr << 1);
308 		total_len = msg->len;
309 		mcp->rxbuf = msg->buf;
310 	} else {
311 		mcp->txbuf[1] = smbus_len;
312 		mcp->txbuf[2] = 0;
313 		mcp->txbuf[3] = (u8)(smbus_addr << 1);
314 		total_len = smbus_len;
315 		mcp->rxbuf = smbus_buf;
316 	}
317 
318 	ret = mcp_send_data_req_status(mcp, mcp->txbuf, 4);
319 	if (ret)
320 		return ret;
321 
322 	mcp->rxbuf_idx = 0;
323 
324 	do {
325 		/* Wait for the data to be read by the device */
326 		usleep_range(980, 1000);
327 
328 		memset(mcp->txbuf, 0, 4);
329 		mcp->txbuf[0] = MCP2221_I2C_GET_DATA;
330 
331 		ret = mcp_send_data_req_status(mcp, mcp->txbuf, 1);
332 		if (ret) {
333 			if (retries < 5) {
334 				/* The data wasn't ready to read.
335 				 * Wait a bit longer and try again.
336 				 */
337 				usleep_range(90, 100);
338 				retries++;
339 			} else {
340 				return ret;
341 			}
342 		} else {
343 			retries = 0;
344 		}
345 	} while (mcp->rxbuf_idx < total_len);
346 
347 	usleep_range(980, 1000);
348 	ret = mcp_chk_last_cmd_status_free_bus(mcp);
349 
350 	return ret;
351 }
352 
mcp_i2c_xfer(struct i2c_adapter * adapter,struct i2c_msg msgs[],int num)353 static int mcp_i2c_xfer(struct i2c_adapter *adapter,
354 				struct i2c_msg msgs[], int num)
355 {
356 	int ret;
357 	struct mcp2221 *mcp = i2c_get_adapdata(adapter);
358 
359 	hid_hw_power(mcp->hdev, PM_HINT_FULLON);
360 
361 	mutex_lock(&mcp->lock);
362 
363 	if (num == 1) {
364 		if (msgs->flags & I2C_M_RD) {
365 			ret = mcp_i2c_smbus_read(mcp, msgs, MCP2221_I2C_RD_DATA,
366 							0, 0, NULL);
367 		} else {
368 			ret = mcp_i2c_write(mcp, msgs, MCP2221_I2C_WR_DATA, 1);
369 		}
370 		if (ret)
371 			goto exit;
372 		ret = num;
373 	} else if (num == 2) {
374 		/* Ex transaction; send reg address and read its contents */
375 		if (msgs[0].addr == msgs[1].addr &&
376 			!(msgs[0].flags & I2C_M_RD) &&
377 			 (msgs[1].flags & I2C_M_RD)) {
378 
379 			ret = mcp_i2c_write(mcp, &msgs[0],
380 						MCP2221_I2C_WR_NO_STOP, 0);
381 			if (ret)
382 				goto exit;
383 
384 			ret = mcp_i2c_smbus_read(mcp, &msgs[1],
385 						MCP2221_I2C_RD_RPT_START,
386 						0, 0, NULL);
387 			if (ret)
388 				goto exit;
389 			ret = num;
390 		} else {
391 			dev_err(&adapter->dev,
392 				"unsupported multi-msg i2c transaction\n");
393 			ret = -EOPNOTSUPP;
394 		}
395 	} else {
396 		dev_err(&adapter->dev,
397 			"unsupported multi-msg i2c transaction\n");
398 		ret = -EOPNOTSUPP;
399 	}
400 
401 exit:
402 	hid_hw_power(mcp->hdev, PM_HINT_NORMAL);
403 	mutex_unlock(&mcp->lock);
404 	return ret;
405 }
406 
mcp_smbus_write(struct mcp2221 * mcp,u16 addr,u8 command,u8 * buf,u8 len,int type,u8 last_status)407 static int mcp_smbus_write(struct mcp2221 *mcp, u16 addr,
408 				u8 command, u8 *buf, u8 len, int type,
409 				u8 last_status)
410 {
411 	int data_len, ret;
412 
413 	mcp->txbuf[0] = type;
414 	mcp->txbuf[1] = len + 1; /* 1 is due to command byte itself */
415 	mcp->txbuf[2] = 0;
416 	mcp->txbuf[3] = (u8)(addr << 1);
417 	mcp->txbuf[4] = command;
418 
419 	switch (len) {
420 	case 0:
421 		data_len = 5;
422 		break;
423 	case 1:
424 		mcp->txbuf[5] = buf[0];
425 		data_len = 6;
426 		break;
427 	case 2:
428 		mcp->txbuf[5] = buf[0];
429 		mcp->txbuf[6] = buf[1];
430 		data_len = 7;
431 		break;
432 	default:
433 		if (len > I2C_SMBUS_BLOCK_MAX)
434 			return -EINVAL;
435 
436 		memcpy(&mcp->txbuf[5], buf, len);
437 		data_len = len + 5;
438 	}
439 
440 	ret = mcp_send_data_req_status(mcp, mcp->txbuf, data_len);
441 	if (ret)
442 		return ret;
443 
444 	if (last_status) {
445 		usleep_range(980, 1000);
446 
447 		ret = mcp_chk_last_cmd_status_free_bus(mcp);
448 	}
449 
450 	return ret;
451 }
452 
mcp_smbus_xfer(struct i2c_adapter * adapter,u16 addr,unsigned short flags,char read_write,u8 command,int size,union i2c_smbus_data * data)453 static int mcp_smbus_xfer(struct i2c_adapter *adapter, u16 addr,
454 				unsigned short flags, char read_write,
455 				u8 command, int size,
456 				union i2c_smbus_data *data)
457 {
458 	int ret;
459 	struct mcp2221 *mcp = i2c_get_adapdata(adapter);
460 
461 	hid_hw_power(mcp->hdev, PM_HINT_FULLON);
462 
463 	mutex_lock(&mcp->lock);
464 
465 	switch (size) {
466 
467 	case I2C_SMBUS_QUICK:
468 		if (read_write == I2C_SMBUS_READ)
469 			ret = mcp_i2c_smbus_read(mcp, NULL, MCP2221_I2C_RD_DATA,
470 						addr, 0, &data->byte);
471 		else
472 			ret = mcp_smbus_write(mcp, addr, command, NULL,
473 						0, MCP2221_I2C_WR_DATA, 1);
474 		break;
475 	case I2C_SMBUS_BYTE:
476 		if (read_write == I2C_SMBUS_READ)
477 			ret = mcp_i2c_smbus_read(mcp, NULL, MCP2221_I2C_RD_DATA,
478 						addr, 1, &data->byte);
479 		else
480 			ret = mcp_smbus_write(mcp, addr, command, NULL,
481 						0, MCP2221_I2C_WR_DATA, 1);
482 		break;
483 	case I2C_SMBUS_BYTE_DATA:
484 		if (read_write == I2C_SMBUS_READ) {
485 			ret = mcp_smbus_write(mcp, addr, command, NULL,
486 						0, MCP2221_I2C_WR_NO_STOP, 0);
487 			if (ret)
488 				goto exit;
489 
490 			ret = mcp_i2c_smbus_read(mcp, NULL,
491 						MCP2221_I2C_RD_RPT_START,
492 						addr, 1, &data->byte);
493 		} else {
494 			ret = mcp_smbus_write(mcp, addr, command, &data->byte,
495 						1, MCP2221_I2C_WR_DATA, 1);
496 		}
497 		break;
498 	case I2C_SMBUS_WORD_DATA:
499 		if (read_write == I2C_SMBUS_READ) {
500 			ret = mcp_smbus_write(mcp, addr, command, NULL,
501 						0, MCP2221_I2C_WR_NO_STOP, 0);
502 			if (ret)
503 				goto exit;
504 
505 			ret = mcp_i2c_smbus_read(mcp, NULL,
506 						MCP2221_I2C_RD_RPT_START,
507 						addr, 2, (u8 *)&data->word);
508 		} else {
509 			ret = mcp_smbus_write(mcp, addr, command,
510 						(u8 *)&data->word, 2,
511 						MCP2221_I2C_WR_DATA, 1);
512 		}
513 		break;
514 	case I2C_SMBUS_BLOCK_DATA:
515 		if (read_write == I2C_SMBUS_READ) {
516 			ret = mcp_smbus_write(mcp, addr, command, NULL,
517 						0, MCP2221_I2C_WR_NO_STOP, 1);
518 			if (ret)
519 				goto exit;
520 
521 			mcp->rxbuf_idx = 0;
522 			mcp->rxbuf = data->block;
523 			mcp->txbuf[0] = MCP2221_I2C_GET_DATA;
524 			ret = mcp_send_data_req_status(mcp, mcp->txbuf, 1);
525 			if (ret)
526 				goto exit;
527 		} else {
528 			if (!data->block[0]) {
529 				ret = -EINVAL;
530 				goto exit;
531 			}
532 			ret = mcp_smbus_write(mcp, addr, command, data->block,
533 						data->block[0] + 1,
534 						MCP2221_I2C_WR_DATA, 1);
535 		}
536 		break;
537 	case I2C_SMBUS_I2C_BLOCK_DATA:
538 		if (read_write == I2C_SMBUS_READ) {
539 			ret = mcp_smbus_write(mcp, addr, command, NULL,
540 						0, MCP2221_I2C_WR_NO_STOP, 1);
541 			if (ret)
542 				goto exit;
543 
544 			mcp->rxbuf_idx = 0;
545 			mcp->rxbuf = data->block;
546 			mcp->txbuf[0] = MCP2221_I2C_GET_DATA;
547 			ret = mcp_send_data_req_status(mcp, mcp->txbuf, 1);
548 			if (ret)
549 				goto exit;
550 		} else {
551 			if (!data->block[0]) {
552 				ret = -EINVAL;
553 				goto exit;
554 			}
555 			ret = mcp_smbus_write(mcp, addr, command,
556 						&data->block[1], data->block[0],
557 						MCP2221_I2C_WR_DATA, 1);
558 		}
559 		break;
560 	case I2C_SMBUS_PROC_CALL:
561 		ret = mcp_smbus_write(mcp, addr, command,
562 						(u8 *)&data->word,
563 						2, MCP2221_I2C_WR_NO_STOP, 0);
564 		if (ret)
565 			goto exit;
566 
567 		ret = mcp_i2c_smbus_read(mcp, NULL,
568 						MCP2221_I2C_RD_RPT_START,
569 						addr, 2, (u8 *)&data->word);
570 		break;
571 	case I2C_SMBUS_BLOCK_PROC_CALL:
572 		ret = mcp_smbus_write(mcp, addr, command, data->block,
573 						data->block[0] + 1,
574 						MCP2221_I2C_WR_NO_STOP, 0);
575 		if (ret)
576 			goto exit;
577 
578 		ret = mcp_i2c_smbus_read(mcp, NULL,
579 						MCP2221_I2C_RD_RPT_START,
580 						addr, I2C_SMBUS_BLOCK_MAX,
581 						data->block);
582 		break;
583 	default:
584 		dev_err(&mcp->adapter.dev,
585 			"unsupported smbus transaction size:%d\n", size);
586 		ret = -EOPNOTSUPP;
587 	}
588 
589 exit:
590 	hid_hw_power(mcp->hdev, PM_HINT_NORMAL);
591 	mutex_unlock(&mcp->lock);
592 	return ret;
593 }
594 
mcp_i2c_func(struct i2c_adapter * adapter)595 static u32 mcp_i2c_func(struct i2c_adapter *adapter)
596 {
597 	return I2C_FUNC_I2C |
598 			I2C_FUNC_SMBUS_READ_BLOCK_DATA |
599 			I2C_FUNC_SMBUS_BLOCK_PROC_CALL |
600 			(I2C_FUNC_SMBUS_EMUL & ~I2C_FUNC_SMBUS_PEC);
601 }
602 
603 static const struct i2c_algorithm mcp_i2c_algo = {
604 	.master_xfer = mcp_i2c_xfer,
605 	.smbus_xfer = mcp_smbus_xfer,
606 	.functionality = mcp_i2c_func,
607 };
608 
609 #if IS_REACHABLE(CONFIG_GPIOLIB)
mcp_gpio_get(struct gpio_chip * gc,unsigned int offset)610 static int mcp_gpio_get(struct gpio_chip *gc,
611 				unsigned int offset)
612 {
613 	int ret;
614 	struct mcp2221 *mcp = gpiochip_get_data(gc);
615 
616 	mcp->txbuf[0] = MCP2221_GPIO_GET;
617 
618 	mcp->gp_idx = offsetof(struct mcp_get_gpio, gpio[offset]);
619 
620 	mutex_lock(&mcp->lock);
621 	ret = mcp_send_data_req_status(mcp, mcp->txbuf, 1);
622 	mutex_unlock(&mcp->lock);
623 
624 	return ret;
625 }
626 
mcp_gpio_set(struct gpio_chip * gc,unsigned int offset,int value)627 static void mcp_gpio_set(struct gpio_chip *gc,
628 				unsigned int offset, int value)
629 {
630 	struct mcp2221 *mcp = gpiochip_get_data(gc);
631 
632 	memset(mcp->txbuf, 0, 18);
633 	mcp->txbuf[0] = MCP2221_GPIO_SET;
634 
635 	mcp->gp_idx = offsetof(struct mcp_set_gpio, gpio[offset].value);
636 
637 	mcp->txbuf[mcp->gp_idx - 1] = 1;
638 	mcp->txbuf[mcp->gp_idx] = !!value;
639 
640 	mutex_lock(&mcp->lock);
641 	mcp_send_data_req_status(mcp, mcp->txbuf, 18);
642 	mutex_unlock(&mcp->lock);
643 }
644 
mcp_gpio_dir_set(struct mcp2221 * mcp,unsigned int offset,u8 val)645 static int mcp_gpio_dir_set(struct mcp2221 *mcp,
646 				unsigned int offset, u8 val)
647 {
648 	memset(mcp->txbuf, 0, 18);
649 	mcp->txbuf[0] = MCP2221_GPIO_SET;
650 
651 	mcp->gp_idx = offsetof(struct mcp_set_gpio, gpio[offset].direction);
652 
653 	mcp->txbuf[mcp->gp_idx - 1] = 1;
654 	mcp->txbuf[mcp->gp_idx] = val;
655 
656 	return mcp_send_data_req_status(mcp, mcp->txbuf, 18);
657 }
658 
mcp_gpio_direction_input(struct gpio_chip * gc,unsigned int offset)659 static int mcp_gpio_direction_input(struct gpio_chip *gc,
660 				unsigned int offset)
661 {
662 	int ret;
663 	struct mcp2221 *mcp = gpiochip_get_data(gc);
664 
665 	mutex_lock(&mcp->lock);
666 	ret = mcp_gpio_dir_set(mcp, offset, MCP2221_DIR_IN);
667 	mutex_unlock(&mcp->lock);
668 
669 	return ret;
670 }
671 
mcp_gpio_direction_output(struct gpio_chip * gc,unsigned int offset,int value)672 static int mcp_gpio_direction_output(struct gpio_chip *gc,
673 				unsigned int offset, int value)
674 {
675 	int ret;
676 	struct mcp2221 *mcp = gpiochip_get_data(gc);
677 
678 	mutex_lock(&mcp->lock);
679 	ret = mcp_gpio_dir_set(mcp, offset, MCP2221_DIR_OUT);
680 	mutex_unlock(&mcp->lock);
681 
682 	/* Can't configure as output, bailout early */
683 	if (ret)
684 		return ret;
685 
686 	mcp_gpio_set(gc, offset, value);
687 
688 	return 0;
689 }
690 
mcp_gpio_get_direction(struct gpio_chip * gc,unsigned int offset)691 static int mcp_gpio_get_direction(struct gpio_chip *gc,
692 				unsigned int offset)
693 {
694 	int ret;
695 	struct mcp2221 *mcp = gpiochip_get_data(gc);
696 
697 	mcp->txbuf[0] = MCP2221_GPIO_GET;
698 
699 	mcp->gp_idx = offsetof(struct mcp_get_gpio, gpio[offset]);
700 
701 	mutex_lock(&mcp->lock);
702 	ret = mcp_send_data_req_status(mcp, mcp->txbuf, 1);
703 	mutex_unlock(&mcp->lock);
704 
705 	if (ret)
706 		return ret;
707 
708 	if (mcp->gpio_dir == MCP2221_DIR_IN)
709 		return GPIO_LINE_DIRECTION_IN;
710 
711 	return GPIO_LINE_DIRECTION_OUT;
712 }
713 #endif
714 
715 /* Gives current state of i2c engine inside mcp2221 */
mcp_get_i2c_eng_state(struct mcp2221 * mcp,u8 * data,u8 idx)716 static int mcp_get_i2c_eng_state(struct mcp2221 *mcp,
717 				u8 *data, u8 idx)
718 {
719 	int ret;
720 
721 	switch (data[idx]) {
722 	case MCP2221_I2C_WRADDRL_NACK:
723 	case MCP2221_I2C_WRADDRL_SEND:
724 		ret = -ENXIO;
725 		break;
726 	case MCP2221_I2C_START_TOUT:
727 	case MCP2221_I2C_STOP_TOUT:
728 	case MCP2221_I2C_WRADDRL_TOUT:
729 	case MCP2221_I2C_WRDATA_TOUT:
730 		ret = -ETIMEDOUT;
731 		break;
732 	case MCP2221_I2C_ENG_BUSY:
733 		ret = -EAGAIN;
734 		break;
735 	case MCP2221_SUCCESS:
736 		ret = 0x00;
737 		break;
738 	default:
739 		ret = -EIO;
740 	}
741 
742 	return ret;
743 }
744 
745 /*
746  * MCP2221 uses interrupt endpoint for input reports. This function
747  * is called by HID layer when it receives i/p report from mcp2221,
748  * which is actually a response to the previously sent command.
749  *
750  * MCP2221A firmware specific return codes are parsed and 0 or
751  * appropriate negative error code is returned. Delayed response
752  * results in timeout error and stray reponses results in -EIO.
753  */
mcp2221_raw_event(struct hid_device * hdev,struct hid_report * report,u8 * data,int size)754 static int mcp2221_raw_event(struct hid_device *hdev,
755 				struct hid_report *report, u8 *data, int size)
756 {
757 	u8 *buf;
758 	struct mcp2221 *mcp = hid_get_drvdata(hdev);
759 
760 	switch (data[0]) {
761 
762 	case MCP2221_I2C_WR_DATA:
763 	case MCP2221_I2C_WR_NO_STOP:
764 	case MCP2221_I2C_RD_DATA:
765 	case MCP2221_I2C_RD_RPT_START:
766 		switch (data[1]) {
767 		case MCP2221_SUCCESS:
768 			mcp->status = 0;
769 			break;
770 		default:
771 			mcp->status = mcp_get_i2c_eng_state(mcp, data, 2);
772 		}
773 		complete(&mcp->wait_in_report);
774 		break;
775 
776 	case MCP2221_I2C_PARAM_OR_STATUS:
777 		switch (data[1]) {
778 		case MCP2221_SUCCESS:
779 			if ((mcp->txbuf[3] == MCP2221_I2C_SET_SPEED) &&
780 				(data[3] != MCP2221_I2C_SET_SPEED)) {
781 				mcp->status = -EAGAIN;
782 				break;
783 			}
784 			if (data[20] & MCP2221_I2C_MASK_ADDR_NACK) {
785 				mcp->status = -ENXIO;
786 				break;
787 			}
788 			mcp->status = mcp_get_i2c_eng_state(mcp, data, 8);
789 #if IS_REACHABLE(CONFIG_IIO)
790 			memcpy(&mcp->adc_values, &data[50], sizeof(mcp->adc_values));
791 #endif
792 			break;
793 		default:
794 			mcp->status = -EIO;
795 		}
796 		complete(&mcp->wait_in_report);
797 		break;
798 
799 	case MCP2221_I2C_GET_DATA:
800 		switch (data[1]) {
801 		case MCP2221_SUCCESS:
802 			if (data[2] == MCP2221_I2C_ADDR_NACK) {
803 				mcp->status = -ENXIO;
804 				break;
805 			}
806 			if (!mcp_get_i2c_eng_state(mcp, data, 2)
807 				&& (data[3] == 0)) {
808 				mcp->status = 0;
809 				break;
810 			}
811 			if (data[3] == 127) {
812 				mcp->status = -EIO;
813 				break;
814 			}
815 			if (data[2] == MCP2221_I2C_READ_COMPL ||
816 			    data[2] == MCP2221_I2C_READ_PARTIAL) {
817 				buf = mcp->rxbuf;
818 				memcpy(&buf[mcp->rxbuf_idx], &data[4], data[3]);
819 				mcp->rxbuf_idx = mcp->rxbuf_idx + data[3];
820 				mcp->status = 0;
821 				break;
822 			}
823 			mcp->status = -EIO;
824 			break;
825 		default:
826 			mcp->status = -EIO;
827 		}
828 		complete(&mcp->wait_in_report);
829 		break;
830 
831 	case MCP2221_GPIO_GET:
832 		switch (data[1]) {
833 		case MCP2221_SUCCESS:
834 			if ((data[mcp->gp_idx] == MCP2221_ALT_F_NOT_GPIOV) ||
835 				(data[mcp->gp_idx + 1] == MCP2221_ALT_F_NOT_GPIOD)) {
836 				mcp->status = -ENOENT;
837 			} else {
838 				mcp->status = !!data[mcp->gp_idx];
839 				mcp->gpio_dir = data[mcp->gp_idx + 1];
840 			}
841 			break;
842 		default:
843 			mcp->status = -EAGAIN;
844 		}
845 		complete(&mcp->wait_in_report);
846 		break;
847 
848 	case MCP2221_GPIO_SET:
849 		switch (data[1]) {
850 		case MCP2221_SUCCESS:
851 			if ((data[mcp->gp_idx] == MCP2221_ALT_F_NOT_GPIOV) ||
852 				(data[mcp->gp_idx - 1] == MCP2221_ALT_F_NOT_GPIOV)) {
853 				mcp->status = -ENOENT;
854 			} else {
855 				mcp->status = 0;
856 			}
857 			break;
858 		default:
859 			mcp->status = -EAGAIN;
860 		}
861 		complete(&mcp->wait_in_report);
862 		break;
863 
864 	case MCP2221_SET_SRAM_SETTINGS:
865 		switch (data[1]) {
866 		case MCP2221_SUCCESS:
867 			mcp->status = 0;
868 			break;
869 		default:
870 			mcp->status = -EAGAIN;
871 		}
872 		complete(&mcp->wait_in_report);
873 		break;
874 
875 	case MCP2221_GET_SRAM_SETTINGS:
876 		switch (data[1]) {
877 		case MCP2221_SUCCESS:
878 			memcpy(&mcp->mode, &data[22], 4);
879 #if IS_REACHABLE(CONFIG_IIO)
880 			mcp->dac_value = data[6] & GENMASK(4, 0);
881 #endif
882 			mcp->status = 0;
883 			break;
884 		default:
885 			mcp->status = -EAGAIN;
886 		}
887 		complete(&mcp->wait_in_report);
888 		break;
889 
890 	case MCP2221_READ_FLASH_DATA:
891 		switch (data[1]) {
892 		case MCP2221_SUCCESS:
893 			mcp->status = 0;
894 
895 			/* Only handles CHIP SETTINGS subpage currently */
896 			if (mcp->txbuf[1] != 0) {
897 				mcp->status = -EIO;
898 				break;
899 			}
900 
901 #if IS_REACHABLE(CONFIG_IIO)
902 			{
903 				u8 tmp;
904 				/* DAC scale value */
905 				tmp = FIELD_GET(GENMASK(7, 6), data[6]);
906 				if ((data[6] & BIT(5)) && tmp)
907 					mcp->dac_scale = tmp + 4;
908 				else
909 					mcp->dac_scale = 5;
910 
911 				/* ADC scale value */
912 				tmp = FIELD_GET(GENMASK(4, 3), data[7]);
913 				if ((data[7] & BIT(2)) && tmp)
914 					mcp->adc_scale = tmp - 1;
915 				else
916 					mcp->adc_scale = 0;
917 			}
918 #endif
919 
920 			break;
921 		default:
922 			mcp->status = -EAGAIN;
923 		}
924 		complete(&mcp->wait_in_report);
925 		break;
926 
927 	default:
928 		mcp->status = -EIO;
929 		complete(&mcp->wait_in_report);
930 	}
931 
932 	return 1;
933 }
934 
935 /* Device resource managed function for HID unregistration */
mcp2221_hid_unregister(void * ptr)936 static void mcp2221_hid_unregister(void *ptr)
937 {
938 	struct hid_device *hdev = ptr;
939 
940 	hid_hw_close(hdev);
941 	hid_hw_stop(hdev);
942 }
943 
944 /* This is needed to be sure hid_hw_stop() isn't called twice by the subsystem */
mcp2221_remove(struct hid_device * hdev)945 static void mcp2221_remove(struct hid_device *hdev)
946 {
947 #if IS_REACHABLE(CONFIG_IIO)
948 	struct mcp2221 *mcp = hid_get_drvdata(hdev);
949 
950 	cancel_delayed_work_sync(&mcp->init_work);
951 #endif
952 }
953 
954 #if IS_REACHABLE(CONFIG_IIO)
mcp2221_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * channel,int * val,int * val2,long mask)955 static int mcp2221_read_raw(struct iio_dev *indio_dev,
956 			    struct iio_chan_spec const *channel, int *val,
957 			    int *val2, long mask)
958 {
959 	struct mcp2221_iio *priv = iio_priv(indio_dev);
960 	struct mcp2221 *mcp = priv->mcp;
961 	int ret;
962 
963 	if (mask == IIO_CHAN_INFO_SCALE) {
964 		if (channel->output)
965 			*val = 1 << mcp->dac_scale;
966 		else
967 			*val = 1 << mcp->adc_scale;
968 
969 		return IIO_VAL_INT;
970 	}
971 
972 	mutex_lock(&mcp->lock);
973 
974 	if (channel->output) {
975 		*val = mcp->dac_value;
976 		ret = IIO_VAL_INT;
977 	} else {
978 		/* Read ADC values */
979 		ret = mcp_chk_last_cmd_status(mcp);
980 
981 		if (!ret) {
982 			*val = le16_to_cpu((__force __le16) mcp->adc_values[channel->address]);
983 			if (*val >= BIT(10))
984 				ret =  -EINVAL;
985 			else
986 				ret = IIO_VAL_INT;
987 		}
988 	}
989 
990 	mutex_unlock(&mcp->lock);
991 
992 	return ret;
993 }
994 
mcp2221_write_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int val,int val2,long mask)995 static int mcp2221_write_raw(struct iio_dev *indio_dev,
996 			     struct iio_chan_spec const *chan,
997 			     int val, int val2, long mask)
998 {
999 	struct mcp2221_iio *priv = iio_priv(indio_dev);
1000 	struct mcp2221 *mcp = priv->mcp;
1001 	int ret;
1002 
1003 	if (val < 0 || val >= BIT(5))
1004 		return -EINVAL;
1005 
1006 	mutex_lock(&mcp->lock);
1007 
1008 	memset(mcp->txbuf, 0, 12);
1009 	mcp->txbuf[0] = MCP2221_SET_SRAM_SETTINGS;
1010 	mcp->txbuf[4] = BIT(7) | val;
1011 
1012 	ret = mcp_send_data_req_status(mcp, mcp->txbuf, 12);
1013 	if (!ret)
1014 		mcp->dac_value = val;
1015 
1016 	mutex_unlock(&mcp->lock);
1017 
1018 	return ret;
1019 }
1020 
1021 static const struct iio_info mcp2221_info = {
1022 	.read_raw = &mcp2221_read_raw,
1023 	.write_raw = &mcp2221_write_raw,
1024 };
1025 
mcp_iio_channels(struct mcp2221 * mcp)1026 static int mcp_iio_channels(struct mcp2221 *mcp)
1027 {
1028 	int idx, cnt = 0;
1029 	bool dac_created = false;
1030 
1031 	/* GP0 doesn't have ADC/DAC alternative function */
1032 	for (idx = 1; idx < MCP_NGPIO; idx++) {
1033 		struct iio_chan_spec *chan = &mcp->iio_channels[cnt];
1034 
1035 		switch (mcp->mode[idx]) {
1036 		case 2:
1037 			chan->address = idx - 1;
1038 			chan->channel = cnt++;
1039 			break;
1040 		case 3:
1041 			/* GP1 doesn't have DAC alternative function */
1042 			if (idx == 1 || dac_created)
1043 				continue;
1044 			/* DAC1 and DAC2 outputs are connected to the same DAC */
1045 			dac_created = true;
1046 			chan->output = 1;
1047 			cnt++;
1048 			break;
1049 		default:
1050 			continue;
1051 		}
1052 
1053 		chan->type = IIO_VOLTAGE;
1054 		chan->indexed = 1;
1055 		chan->info_mask_separate = BIT(IIO_CHAN_INFO_RAW);
1056 		chan->info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE);
1057 		chan->scan_index = -1;
1058 	}
1059 
1060 	return cnt;
1061 }
1062 
mcp_init_work(struct work_struct * work)1063 static void mcp_init_work(struct work_struct *work)
1064 {
1065 	struct iio_dev *indio_dev;
1066 	struct mcp2221 *mcp = container_of(work, struct mcp2221, init_work.work);
1067 	struct mcp2221_iio *data;
1068 	static int retries = 5;
1069 	int ret, num_channels;
1070 
1071 	hid_hw_power(mcp->hdev, PM_HINT_FULLON);
1072 	mutex_lock(&mcp->lock);
1073 
1074 	mcp->txbuf[0] = MCP2221_GET_SRAM_SETTINGS;
1075 	ret = mcp_send_data_req_status(mcp, mcp->txbuf, 1);
1076 
1077 	if (ret == -EAGAIN)
1078 		goto reschedule_task;
1079 
1080 	num_channels = mcp_iio_channels(mcp);
1081 	if (!num_channels)
1082 		goto unlock;
1083 
1084 	mcp->txbuf[0] = MCP2221_READ_FLASH_DATA;
1085 	mcp->txbuf[1] = 0;
1086 	ret = mcp_send_data_req_status(mcp, mcp->txbuf, 2);
1087 
1088 	if (ret == -EAGAIN)
1089 		goto reschedule_task;
1090 
1091 	indio_dev = devm_iio_device_alloc(&mcp->hdev->dev, sizeof(*data));
1092 	if (!indio_dev)
1093 		goto unlock;
1094 
1095 	data = iio_priv(indio_dev);
1096 	data->mcp = mcp;
1097 
1098 	indio_dev->name = "mcp2221";
1099 	indio_dev->modes = INDIO_DIRECT_MODE;
1100 	indio_dev->info = &mcp2221_info;
1101 	indio_dev->channels = mcp->iio_channels;
1102 	indio_dev->num_channels = num_channels;
1103 
1104 	devm_iio_device_register(&mcp->hdev->dev, indio_dev);
1105 
1106 unlock:
1107 	mutex_unlock(&mcp->lock);
1108 	hid_hw_power(mcp->hdev, PM_HINT_NORMAL);
1109 
1110 	return;
1111 
1112 reschedule_task:
1113 	mutex_unlock(&mcp->lock);
1114 	hid_hw_power(mcp->hdev, PM_HINT_NORMAL);
1115 
1116 	if (!retries--)
1117 		return;
1118 
1119 	/* Device is not ready to read SRAM or FLASH data, try again */
1120 	schedule_delayed_work(&mcp->init_work, msecs_to_jiffies(100));
1121 }
1122 #endif
1123 
mcp2221_probe(struct hid_device * hdev,const struct hid_device_id * id)1124 static int mcp2221_probe(struct hid_device *hdev,
1125 					const struct hid_device_id *id)
1126 {
1127 	int ret;
1128 	struct mcp2221 *mcp;
1129 
1130 	mcp = devm_kzalloc(&hdev->dev, sizeof(*mcp), GFP_KERNEL);
1131 	if (!mcp)
1132 		return -ENOMEM;
1133 
1134 	ret = hid_parse(hdev);
1135 	if (ret) {
1136 		hid_err(hdev, "can't parse reports\n");
1137 		return ret;
1138 	}
1139 
1140 	/*
1141 	 * This driver uses the .raw_event callback and therefore does not need any
1142 	 * HID_CONNECT_xxx flags.
1143 	 */
1144 	ret = hid_hw_start(hdev, 0);
1145 	if (ret) {
1146 		hid_err(hdev, "can't start hardware\n");
1147 		return ret;
1148 	}
1149 
1150 	hid_info(hdev, "USB HID v%x.%02x Device [%s] on %s\n", hdev->version >> 8,
1151 			hdev->version & 0xff, hdev->name, hdev->phys);
1152 
1153 	ret = hid_hw_open(hdev);
1154 	if (ret) {
1155 		hid_err(hdev, "can't open device\n");
1156 		hid_hw_stop(hdev);
1157 		return ret;
1158 	}
1159 
1160 	mutex_init(&mcp->lock);
1161 	init_completion(&mcp->wait_in_report);
1162 	hid_set_drvdata(hdev, mcp);
1163 	mcp->hdev = hdev;
1164 
1165 	ret = devm_add_action_or_reset(&hdev->dev, mcp2221_hid_unregister, hdev);
1166 	if (ret)
1167 		return ret;
1168 
1169 	hid_device_io_start(hdev);
1170 
1171 	/* Set I2C bus clock diviser */
1172 	if (i2c_clk_freq > 400)
1173 		i2c_clk_freq = 400;
1174 	if (i2c_clk_freq < 50)
1175 		i2c_clk_freq = 50;
1176 	mcp->cur_i2c_clk_div = (12000000 / (i2c_clk_freq * 1000)) - 3;
1177 	ret = mcp_set_i2c_speed(mcp);
1178 	if (ret) {
1179 		hid_err(hdev, "can't set i2c speed: %d\n", ret);
1180 		return ret;
1181 	}
1182 
1183 	mcp->adapter.owner = THIS_MODULE;
1184 	mcp->adapter.class = I2C_CLASS_HWMON;
1185 	mcp->adapter.algo = &mcp_i2c_algo;
1186 	mcp->adapter.retries = 1;
1187 	mcp->adapter.dev.parent = &hdev->dev;
1188 	ACPI_COMPANION_SET(&mcp->adapter.dev, ACPI_COMPANION(hdev->dev.parent));
1189 	snprintf(mcp->adapter.name, sizeof(mcp->adapter.name),
1190 			"MCP2221 usb-i2c bridge");
1191 
1192 	i2c_set_adapdata(&mcp->adapter, mcp);
1193 	ret = devm_i2c_add_adapter(&hdev->dev, &mcp->adapter);
1194 	if (ret) {
1195 		hid_err(hdev, "can't add usb-i2c adapter: %d\n", ret);
1196 		return ret;
1197 	}
1198 
1199 #if IS_REACHABLE(CONFIG_GPIOLIB)
1200 	/* Setup GPIO chip */
1201 	mcp->gc = devm_kzalloc(&hdev->dev, sizeof(*mcp->gc), GFP_KERNEL);
1202 	if (!mcp->gc)
1203 		return -ENOMEM;
1204 
1205 	mcp->gc->label = "mcp2221_gpio";
1206 	mcp->gc->direction_input = mcp_gpio_direction_input;
1207 	mcp->gc->direction_output = mcp_gpio_direction_output;
1208 	mcp->gc->get_direction = mcp_gpio_get_direction;
1209 	mcp->gc->set = mcp_gpio_set;
1210 	mcp->gc->get = mcp_gpio_get;
1211 	mcp->gc->ngpio = MCP_NGPIO;
1212 	mcp->gc->base = -1;
1213 	mcp->gc->can_sleep = 1;
1214 	mcp->gc->parent = &hdev->dev;
1215 
1216 	ret = devm_gpiochip_add_data(&hdev->dev, mcp->gc, mcp);
1217 	if (ret)
1218 		return ret;
1219 #endif
1220 
1221 #if IS_REACHABLE(CONFIG_IIO)
1222 	INIT_DELAYED_WORK(&mcp->init_work, mcp_init_work);
1223 	schedule_delayed_work(&mcp->init_work, msecs_to_jiffies(100));
1224 #endif
1225 
1226 	return 0;
1227 }
1228 
1229 static const struct hid_device_id mcp2221_devices[] = {
1230 	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_MCP2221) },
1231 	{ }
1232 };
1233 MODULE_DEVICE_TABLE(hid, mcp2221_devices);
1234 
1235 static struct hid_driver mcp2221_driver = {
1236 	.name		= "mcp2221",
1237 	.id_table	= mcp2221_devices,
1238 	.probe		= mcp2221_probe,
1239 	.remove		= mcp2221_remove,
1240 	.raw_event	= mcp2221_raw_event,
1241 };
1242 
1243 /* Register with HID core */
1244 module_hid_driver(mcp2221_driver);
1245 
1246 MODULE_AUTHOR("Rishi Gupta <gupt21@gmail.com>");
1247 MODULE_DESCRIPTION("MCP2221 Microchip HID USB to I2C master bridge");
1248 MODULE_LICENSE("GPL v2");
1249