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