drivers/hid/hid-mcp2221.c

   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 */
 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  */
 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 */
 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 */
 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  */
 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
 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  */
 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  */
 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
 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
 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
 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
 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)
 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
 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
 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
 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
 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
 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 */
 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  */
 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 */
 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 */
 945 static void mcp2221_remove(struct hid_device *hdev)
 946 {
 947         struct mcp2221 *mcp = hid_get_drvdata(hdev);
 948
 949         cancel_delayed_work_sync(&mcp->init_work);
 950 }
 951
 952 #if IS_REACHABLE(CONFIG_IIO)
 953 static int mcp2221_read_raw(struct iio_dev *indio_dev,
 954                             struct iio_chan_spec const *channel, int *val,
 955                             int *val2, long mask)
 956 {
 957         struct mcp2221_iio *priv = iio_priv(indio_dev);
 958         struct mcp2221 *mcp = priv->mcp;
 959         int ret;
 960
 961         if (mask == IIO_CHAN_INFO_SCALE) {
 962                 if (channel->output)
 963                         *val = 1 << mcp->dac_scale;
 964                 else
 965                         *val = 1 << mcp->adc_scale;
 966
 967                 return IIO_VAL_INT;
 968         }
 969
 970         mutex_lock(&mcp->lock);
 971
 972         if (channel->output) {
 973                 *val = mcp->dac_value;
 974                 ret = IIO_VAL_INT;
 975         } else {
 976                 /* Read ADC values */
 977                 ret = mcp_chk_last_cmd_status(mcp);
 978
 979                 if (!ret) {
 980                         *val = le16_to_cpu((__force __le16) mcp->adc_values[channel->address]);
 981                         if (*val >= BIT(10))
 982                                 ret =  -EINVAL;
 983                         else
 984                                 ret = IIO_VAL_INT;
 985                 }
 986         }
 987
 988         mutex_unlock(&mcp->lock);
 989
 990         return ret;
 991 }
 992
 993 static int mcp2221_write_raw(struct iio_dev *indio_dev,
 994                              struct iio_chan_spec const *chan,
 995                              int val, int val2, long mask)
 996 {
 997         struct mcp2221_iio *priv = iio_priv(indio_dev);
 998         struct mcp2221 *mcp = priv->mcp;
 999         int ret;
1000
1001         if (val < 0 || val >= BIT(5))
1002                 return -EINVAL;
1003
1004         mutex_lock(&mcp->lock);
1005
1006         memset(mcp->txbuf, 0, 12);
1007         mcp->txbuf[0] = MCP2221_SET_SRAM_SETTINGS;
1008         mcp->txbuf[4] = BIT(7) | val;
1009
1010         ret = mcp_send_data_req_status(mcp, mcp->txbuf, 12);
1011         if (!ret)
1012                 mcp->dac_value = val;
1013
1014         mutex_unlock(&mcp->lock);
1015
1016         return ret;
1017 }
1018
1019 static const struct iio_info mcp2221_info = {
1020         .read_raw = &mcp2221_read_raw,
1021         .write_raw = &mcp2221_write_raw,
1022 };
1023
1024 static int mcp_iio_channels(struct mcp2221 *mcp)
1025 {
1026         int idx, cnt = 0;
1027         bool dac_created = false;
1028
1029         /* GP0 doesn't have ADC/DAC alternative function */
1030         for (idx = 1; idx < MCP_NGPIO; idx++) {
1031                 struct iio_chan_spec *chan = &mcp->iio_channels[cnt];
1032
1033                 switch (mcp->mode[idx]) {
1034                 case 2:
1035                         chan->address = idx - 1;
1036                         chan->channel = cnt++;
1037                         break;
1038                 case 3:
1039                         /* GP1 doesn't have DAC alternative function */
1040                         if (idx == 1 || dac_created)
1041                                 continue;
1042                         /* DAC1 and DAC2 outputs are connected to the same DAC */
1043                         dac_created = true;
1044                         chan->output = 1;
1045                         cnt++;
1046                         break;
1047                 default:
1048                         continue;
1049                 };
1050
1051                 chan->type = IIO_VOLTAGE;
1052                 chan->indexed = 1;
1053                 chan->info_mask_separate = BIT(IIO_CHAN_INFO_RAW);
1054                 chan->info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE);
1055                 chan->scan_index = -1;
1056         }
1057
1058         return cnt;
1059 }
1060
1061 static void mcp_init_work(struct work_struct *work)
1062 {
1063         struct iio_dev *indio_dev;
1064         struct mcp2221 *mcp = container_of(work, struct mcp2221, init_work.work);
1065         struct mcp2221_iio *data;
1066         static int retries = 5;
1067         int ret, num_channels;
1068
1069         hid_hw_power(mcp->hdev, PM_HINT_FULLON);
1070         mutex_lock(&mcp->lock);
1071
1072         mcp->txbuf[0] = MCP2221_GET_SRAM_SETTINGS;
1073         ret = mcp_send_data_req_status(mcp, mcp->txbuf, 1);
1074
1075         if (ret == -EAGAIN)
1076                 goto reschedule_task;
1077
1078         num_channels = mcp_iio_channels(mcp);
1079         if (!num_channels)
1080                 goto unlock;
1081
1082         mcp->txbuf[0] = MCP2221_READ_FLASH_DATA;
1083         mcp->txbuf[1] = 0;
1084         ret = mcp_send_data_req_status(mcp, mcp->txbuf, 2);
1085
1086         if (ret == -EAGAIN)
1087                 goto reschedule_task;
1088
1089         indio_dev = devm_iio_device_alloc(&mcp->hdev->dev, sizeof(*data));
1090         if (!indio_dev)
1091                 goto unlock;
1092
1093         data = iio_priv(indio_dev);
1094         data->mcp = mcp;
1095
1096         indio_dev->name = "mcp2221";
1097         indio_dev->modes = INDIO_DIRECT_MODE;
1098         indio_dev->info = &mcp2221_info;
1099         indio_dev->channels = mcp->iio_channels;
1100         indio_dev->num_channels = num_channels;
1101
1102         devm_iio_device_register(&mcp->hdev->dev, indio_dev);
1103
1104 unlock:
1105         mutex_unlock(&mcp->lock);
1106         hid_hw_power(mcp->hdev, PM_HINT_NORMAL);
1107
1108         return;
1109
1110 reschedule_task:
1111         mutex_unlock(&mcp->lock);
1112         hid_hw_power(mcp->hdev, PM_HINT_NORMAL);
1113
1114         if (!retries--)
1115                 return;
1116
1117         /* Device is not ready to read SRAM or FLASH data, try again */
1118         schedule_delayed_work(&mcp->init_work, msecs_to_jiffies(100));
1119 }
1120 #endif
1121
1122 static int mcp2221_probe(struct hid_device *hdev,
1123                                         const struct hid_device_id *id)
1124 {
1125         int ret;
1126         struct mcp2221 *mcp;
1127
1128         mcp = devm_kzalloc(&hdev->dev, sizeof(*mcp), GFP_KERNEL);
1129         if (!mcp)
1130                 return -ENOMEM;
1131
1132         ret = hid_parse(hdev);
1133         if (ret) {
1134                 hid_err(hdev, "can't parse reports\n");
1135                 return ret;
1136         }
1137
1138         /*
1139          * This driver uses the .raw_event callback and therefore does not need any
1140          * HID_CONNECT_xxx flags.
1141          */
1142         ret = hid_hw_start(hdev, 0);
1143         if (ret) {
1144                 hid_err(hdev, "can't start hardware\n");
1145                 return ret;
1146         }
1147
1148         hid_info(hdev, "USB HID v%x.%02x Device [%s] on %s\n", hdev->version >> 8,
1149                         hdev->version & 0xff, hdev->name, hdev->phys);
1150
1151         ret = hid_hw_open(hdev);
1152         if (ret) {
1153                 hid_err(hdev, "can't open device\n");
1154                 hid_hw_stop(hdev);
1155                 return ret;
1156         }
1157
1158         mutex_init(&mcp->lock);
1159         init_completion(&mcp->wait_in_report);
1160         hid_set_drvdata(hdev, mcp);
1161         mcp->hdev = hdev;
1162
1163         ret = devm_add_action_or_reset(&hdev->dev, mcp2221_hid_unregister, hdev);
1164         if (ret)
1165                 return ret;
1166
1167         hid_device_io_start(hdev);
1168
1169         /* Set I2C bus clock diviser */
1170         if (i2c_clk_freq > 400)
1171                 i2c_clk_freq = 400;
1172         if (i2c_clk_freq < 50)
1173                 i2c_clk_freq = 50;
1174         mcp->cur_i2c_clk_div = (12000000 / (i2c_clk_freq * 1000)) - 3;
1175         ret = mcp_set_i2c_speed(mcp);
1176         if (ret) {
1177                 hid_err(hdev, "can't set i2c speed: %d\n", ret);
1178                 return ret;
1179         }
1180
1181         mcp->adapter.owner = THIS_MODULE;
1182         mcp->adapter.class = I2C_CLASS_HWMON;
1183         mcp->adapter.algo = &mcp_i2c_algo;
1184         mcp->adapter.retries = 1;
1185         mcp->adapter.dev.parent = &hdev->dev;
1186         ACPI_COMPANION_SET(&mcp->adapter.dev, ACPI_COMPANION(hdev->dev.parent));
1187         snprintf(mcp->adapter.name, sizeof(mcp->adapter.name),
1188                         "MCP2221 usb-i2c bridge");
1189
1190         i2c_set_adapdata(&mcp->adapter, mcp);
1191         ret = devm_i2c_add_adapter(&hdev->dev, &mcp->adapter);
1192         if (ret) {
1193                 hid_err(hdev, "can't add usb-i2c adapter: %d\n", ret);
1194                 return ret;
1195         }
1196
1197 #if IS_REACHABLE(CONFIG_GPIOLIB)
1198         /* Setup GPIO chip */
1199         mcp->gc = devm_kzalloc(&hdev->dev, sizeof(*mcp->gc), GFP_KERNEL);
1200         if (!mcp->gc)
1201                 return -ENOMEM;
1202
1203         mcp->gc->label = "mcp2221_gpio";
1204         mcp->gc->direction_input = mcp_gpio_direction_input;
1205         mcp->gc->direction_output = mcp_gpio_direction_output;
1206         mcp->gc->get_direction = mcp_gpio_get_direction;
1207         mcp->gc->set = mcp_gpio_set;
1208         mcp->gc->get = mcp_gpio_get;
1209         mcp->gc->ngpio = MCP_NGPIO;
1210         mcp->gc->base = -1;
1211         mcp->gc->can_sleep = 1;
1212         mcp->gc->parent = &hdev->dev;
1213
1214         ret = devm_gpiochip_add_data(&hdev->dev, mcp->gc, mcp);
1215         if (ret)
1216                 return ret;
1217 #endif
1218
1219 #if IS_REACHABLE(CONFIG_IIO)
1220         INIT_DELAYED_WORK(&mcp->init_work, mcp_init_work);
1221         schedule_delayed_work(&mcp->init_work, msecs_to_jiffies(100));
1222 #endif
1223
1224         return 0;
1225 }
1226
1227 static const struct hid_device_id mcp2221_devices[] = {
1228         { HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_MCP2221) },
1229         { }
1230 };
1231 MODULE_DEVICE_TABLE(hid, mcp2221_devices);
1232
1233 static struct hid_driver mcp2221_driver = {
1234         .name           = "mcp2221",
1235         .id_table       = mcp2221_devices,
1236         .probe          = mcp2221_probe,
1237         .remove         = mcp2221_remove,
1238         .raw_event      = mcp2221_raw_event,
1239 };
1240
1241 /* Register with HID core */
1242 module_hid_driver(mcp2221_driver);
1243
1244 MODULE_AUTHOR("Rishi Gupta <gupt21@gmail.com>");
1245 MODULE_DESCRIPTION("MCP2221 Microchip HID USB to I2C master bridge");
1246 MODULE_LICENSE("GPL v2");