From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-6.6 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,FREEMAIL_FORGED_FROMDOMAIN,FREEMAIL_FROM, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_HELO_NONE,SPF_PASS autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 38D25C352A3 for ; Mon, 10 Feb 2020 13:50:38 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id EBFBF2085B for ; Mon, 10 Feb 2020 13:50:37 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="PMO2wx2b" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1728825AbgBJNuh (ORCPT ); Mon, 10 Feb 2020 08:50:37 -0500 Received: from mail-qv1-f67.google.com ([209.85.219.67]:41053 "EHLO mail-qv1-f67.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727566AbgBJNuh (ORCPT ); Mon, 10 Feb 2020 08:50:37 -0500 Received: by mail-qv1-f67.google.com with SMTP id s7so3170011qvn.8; Mon, 10 Feb 2020 05:50:35 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=mime-version:references:in-reply-to:from:date:message-id:subject:to :cc; bh=NFoMAQhQrGJZb/UiCvMuWBbVNxpZztlQNxbZMtuzc7U=; b=PMO2wx2bwhW2nLwYwgtrm4c8fN3l7glk93b2Cv0R0GoqImQ6skvhkY2XKq9uo6KYdT wvpk5eEcmdVNvXaeLaUEDDcLT9y31yyJpq4eMVovRJt2VUWB96LjXA39SqA3/Crox+1d T5pkFb/XQwSWigWMbH+B9IxxQYENIKzWBek952c/A/msOyKMR9Efn5k4XCb9nh2+y6Ts mu6t1lZZQ4Lhn80F4QY545pDQSwfKaIruWOZbBDmtglxonMjaQI8v/Ld9rh11LQrI+Rq +v5otQaF+DJXMplYnvEMxeYJk0jLDBIaz7Unl0xi5h/Tp/FxOciw/YbFqviZdnRLgDRE QJuQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc; bh=NFoMAQhQrGJZb/UiCvMuWBbVNxpZztlQNxbZMtuzc7U=; b=MBNnz+GTL6KGl7RvHzU313WmLkP6YiS7kP8NbrREnNTWyomPLJf+Rlz7ExXzuZsu/M fgRCDATB77odgCe7/sSjzTLF3iN2yi4JzE6ntlZYDpjJ6/21nEgOIlHsRL0BFuoVMqoX nKdb8rweauDEe/Dmv1QDE8vw0qSzQegeOstBW/xZQAb1bR3zlgtPw6jkmJhWzUs4+dwD GOQAFH3cXGUHTQnEY1jPLTw8BjGcQwMs5rKo5piNKYBeNzo/geNxm4Ugvt71OWz9+dBd f2lc5FTr91qc2FXVu4UUXny6HjSqX86zrT4pk0nCyMXJnKlgjcTz7KlvOMZJa4fldalk /wPg== X-Gm-Message-State: APjAAAXpbw0GUvUCNV8ZWavHn3PICJ06ILZ5bNqVz0wPyyevMHd/DU73 Is1Ot4jKLjj1kOfK85pf1tgRd8HzMnmPWb6yYWsvLA== X-Google-Smtp-Source: APXvYqyphecxuRclYvYVC94sqdG1apvySWAmSHjNkyS8HaWPtj2TbIGNWj3W4bFINE80nMzLzjAA25+pAFR2kOoD8BI= X-Received: by 2002:ad4:408c:: with SMTP id l12mr10284779qvp.164.1581342634973; Mon, 10 Feb 2020 05:50:34 -0800 (PST) MIME-Version: 1.0 References: <1580185137-11255-1-git-send-email-gupt21@gmail.com> In-Reply-To: <1580185137-11255-1-git-send-email-gupt21@gmail.com> From: rishi gupta Date: Mon, 10 Feb 2020 19:20:23 +0530 Message-ID: Subject: Re: [PATCH v3] HID: mcp2221: add usb to i2c-smbus host bridge To: Jiri Kosina , Benjamin Tissoires , wsa+renesas@sang-engineering.com Cc: Greg KH , Linux I2C , "open list:HID CORE LAYER" , lkml Content-Type: text/plain; charset="UTF-8" Sender: linux-input-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-input@vger.kernel.org Humble request for review (all suggestions addressed & tested). GPIO support is also ready, once this patch is Acknowledged I will submit that also. Regards, Rishi On Tue, Jan 28, 2020 at 9:49 AM Rishi Gupta wrote: > > MCP2221 is a USB HID to I2C/SMbus host bridge device. This > commit implements i2c and smbus host adapter support. 7-bit > address and i2c multi-message transaction is also supported. > > Signed-off-by: Rishi Gupta > --- > > Changes in v3: > * Removed all direct USB related references > * Replaced defines with enum > * Replaced HID_CONNECT_DEFAULT with HID_CONNECT_HIDRAW > * Removed depends on HIDRAW in Kconfig > * Used memset wherever possible > * Emit more clear log - unsupported multi-msg i2c transaction > * Removed mcp2221 entry from hid-quirk.c > * Removed module parameter to set i2c bus speed > > MAINTAINERS | 7 + > drivers/hid/Kconfig | 10 + > drivers/hid/Makefile | 1 + > drivers/hid/hid-ids.h | 1 + > drivers/hid/hid-mcp2221.c | 742 ++++++++++++++++++++++++++++++++++++++++++++++ > 5 files changed, 761 insertions(+) > create mode 100644 drivers/hid/hid-mcp2221.c > > diff --git a/MAINTAINERS b/MAINTAINERS > index 141b8d3..bfcdd55 100644 > --- a/MAINTAINERS > +++ b/MAINTAINERS > @@ -10160,6 +10160,13 @@ F: drivers/net/can/m_can/m_can.c > F: drivers/net/can/m_can/m_can.h > F: drivers/net/can/m_can/m_can_platform.c > > +MCP2221A MICROCHIP USB-HID TO I2C BRIDGE DRIVER > +M: Rishi Gupta > +L: linux-i2c@vger.kernel.org > +L: linux-input@vger.kernel.org > +S: Maintained > +F: drivers/hid/hid-mcp2221.c > + > MCP4018 AND MCP4531 MICROCHIP DIGITAL POTENTIOMETER DRIVERS > M: Peter Rosin > L: linux-iio@vger.kernel.org > diff --git a/drivers/hid/Kconfig b/drivers/hid/Kconfig > index 494a39e..5db6e6a 100644 > --- a/drivers/hid/Kconfig > +++ b/drivers/hid/Kconfig > @@ -1145,6 +1145,16 @@ config HID_ALPS > Say Y here if you have a Alps touchpads over i2c-hid or usbhid > and want support for its special functionalities. > > +config HID_MCP2221 > + tristate "Microchip MCP2221 HID USB-to-I2C/SMbus host support" > + depends on USB_HID && I2C > + ---help--- > + Provides I2C and SMBUS host adapter functionality over USB-HID > + through MCP2221 device. > + > + To compile this driver as a module, choose M here: the module > + will be called hid-mcp2221.ko. > + > endmenu > > endif # HID > diff --git a/drivers/hid/Makefile b/drivers/hid/Makefile > index bfefa36..21052a7 100644 > --- a/drivers/hid/Makefile > +++ b/drivers/hid/Makefile > @@ -70,6 +70,7 @@ obj-$(CONFIG_HID_LOGITECH_HIDPP) += hid-logitech-hidpp.o > obj-$(CONFIG_HID_MACALLY) += hid-macally.o > obj-$(CONFIG_HID_MAGICMOUSE) += hid-magicmouse.o > obj-$(CONFIG_HID_MALTRON) += hid-maltron.o > +obj-$(CONFIG_HID_MCP2221) += hid-mcp2221.o > obj-$(CONFIG_HID_MAYFLASH) += hid-mf.o > obj-$(CONFIG_HID_MICROSOFT) += hid-microsoft.o > obj-$(CONFIG_HID_MONTEREY) += hid-monterey.o > diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h > index 3a400ce..53236ac 100644 > --- a/drivers/hid/hid-ids.h > +++ b/drivers/hid/hid-ids.h > @@ -819,6 +819,7 @@ > #define USB_DEVICE_ID_PICK16F1454 0x0042 > #define USB_DEVICE_ID_PICK16F1454_V2 0xf2f7 > #define USB_DEVICE_ID_LUXAFOR 0xf372 > +#define USB_DEVICE_ID_MCP2221 0x00dd > > #define USB_VENDOR_ID_MICROSOFT 0x045e > #define USB_DEVICE_ID_SIDEWINDER_GV 0x003b > diff --git a/drivers/hid/hid-mcp2221.c b/drivers/hid/hid-mcp2221.c > new file mode 100644 > index 0000000..d958475 > --- /dev/null > +++ b/drivers/hid/hid-mcp2221.c > @@ -0,0 +1,742 @@ > +// SPDX-License-Identifier: GPL-2.0-only > +/* > + * MCP2221A - Microchip USB to I2C Host Protocol Bridge > + * > + * Copyright (c) 2020, Rishi Gupta > + * > + * Datasheet: http://ww1.microchip.com/downloads/en/DeviceDoc/20005565B.pdf > + */ > + > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include "hid-ids.h" > + > +/* Commands codes in a raw output report */ > +enum { > + MCP2221_I2C_WR_DATA = 0x90, > + MCP2221_I2C_WR_NO_STOP = 0x94, > + MCP2221_I2C_RD_DATA = 0x91, > + MCP2221_I2C_RD_RPT_START = 0x93, > + MCP2221_I2C_GET_DATA = 0x40, > + MCP2221_I2C_PARAM_OR_STATUS = 0x10, > + MCP2221_I2C_SET_SPEED = 0x20, > + MCP2221_I2C_CANCEL = 0x10, > +}; > + > +/* Response codes in a raw input report */ > +enum { > + MCP2221_SUCCESS = 0x00, > + MCP2221_I2C_ENG_BUSY = 0x01, > + MCP2221_I2C_START_TOUT = 0x12, > + MCP2221_I2C_STOP_TOUT = 0x62, > + MCP2221_I2C_WRADDRL_TOUT = 0x23, > + MCP2221_I2C_WRDATA_TOUT = 0x44, > + MCP2221_I2C_WRADDRL_NACK = 0x25, > + MCP2221_I2C_MASK_ADDR_NACK = 0x40, > + MCP2221_I2C_WRADDRL_SEND = 0x21, > + MCP2221_I2C_ADDR_NACK = 0x25, > + MCP2221_I2C_READ_COMPL = 0x55, > +}; > + > +/* > + * There is no way to distinguish responses. Therefore next command > + * is sent only after response to previous has been received. Mutex > + * lock is used for this purpose mainly. > + */ > +struct mcp2221 { > + struct hid_device *hdev; > + struct i2c_adapter adapter; > + struct mutex lock; > + struct completion wait_in_report; > + u8 *rxbuf; > + u8 txbuf[64]; > + int rxbuf_idx; > + int status; > + u8 cur_i2c_clk_div; > +}; > + > +/* > + * Default i2c bus clock frequency 400 kHz. Modify this if you > + * want to set some other frequency (min 50 kHz - max 400 kHz). > + */ > +static uint i2c_clk_freq = 400; > + > +/* Synchronously send output report to the device */ > +static int mcp_send_report(struct mcp2221 *mcp, > + u8 *out_report, size_t len) > +{ > + u8 *buf; > + int ret; > + > + buf = kmemdup(out_report, len, GFP_KERNEL); > + if (!buf) > + return -ENOMEM; > + > + /* mcp2221 uses interrupt endpoint for out reports */ > + ret = hid_hw_output_report(mcp->hdev, buf, len); > + kfree(buf); > + > + if (ret < 0) > + return ret; > + return 0; > +} > + > +/* > + * Send o/p report to the device and wait for i/p report to be > + * received from the device. If the device does not respond, > + * we timeout. > + */ > +static int mcp_send_data_req_status(struct mcp2221 *mcp, > + u8 *out_report, int len) > +{ > + int ret; > + unsigned long t; > + > + reinit_completion(&mcp->wait_in_report); > + > + ret = mcp_send_report(mcp, out_report, len); > + if (ret) > + return ret; > + > + t = wait_for_completion_timeout(&mcp->wait_in_report, > + msecs_to_jiffies(4000)); > + if (!t) > + return -ETIMEDOUT; > + > + return mcp->status; > +} > + > +/* Check pass/fail for actual communication with i2c slave */ > +static int mcp_chk_last_cmd_status(struct mcp2221 *mcp) > +{ > + memset(mcp->txbuf, 0, 8); > + mcp->txbuf[0] = MCP2221_I2C_PARAM_OR_STATUS; > + > + return mcp_send_data_req_status(mcp, mcp->txbuf, 8); > +} > + > +/* Cancels last command releasing i2c bus just in case occupied */ > +static int mcp_cancel_last_cmd(struct mcp2221 *mcp) > +{ > + memset(mcp->txbuf, 0, 8); > + mcp->txbuf[0] = MCP2221_I2C_PARAM_OR_STATUS; > + mcp->txbuf[2] = MCP2221_I2C_CANCEL; > + > + return mcp_send_data_req_status(mcp, mcp->txbuf, 8); > +} > + > +static int mcp_set_i2c_speed(struct mcp2221 *mcp) > +{ > + int ret; > + > + memset(mcp->txbuf, 0, 8); > + mcp->txbuf[0] = MCP2221_I2C_PARAM_OR_STATUS; > + mcp->txbuf[3] = MCP2221_I2C_SET_SPEED; > + mcp->txbuf[4] = mcp->cur_i2c_clk_div; > + > + ret = mcp_send_data_req_status(mcp, mcp->txbuf, 8); > + if (ret) { > + /* Small delay is needed here */ > + usleep_range(980, 1000); > + mcp_cancel_last_cmd(mcp); > + } > + > + return 0; > +} > + > +/* > + * An output report can contain minimum 1 and maximum 60 user data > + * bytes. If the number of data bytes is more then 60, we send it > + * in chunks of 60 bytes. Last chunk may contain exactly 60 or less > + * bytes. Total number of bytes is informed in very first report to > + * mcp2221, from that point onwards it first collect all the data > + * from host and then send to i2c slave device. > + */ > +static int mcp_i2c_write(struct mcp2221 *mcp, > + struct i2c_msg *msg, int type, u8 last_status) > +{ > + int ret, len, idx, sent; > + > + idx = 0; > + sent = 0; > + if (msg->len < 60) > + len = msg->len; > + else > + len = 60; > + > + do { > + mcp->txbuf[0] = type; > + mcp->txbuf[1] = msg->len & 0xff; > + mcp->txbuf[2] = msg->len >> 8; > + mcp->txbuf[3] = (u8)(msg->addr << 1); > + > + memcpy(&mcp->txbuf[4], &msg->buf[idx], len); > + > + ret = mcp_send_data_req_status(mcp, mcp->txbuf, len + 4); > + if (ret) > + return ret; > + > + usleep_range(980, 1000); > + > + if (last_status) { > + ret = mcp_chk_last_cmd_status(mcp); > + if (ret) > + return ret; > + } > + > + sent = sent + len; > + if (sent >= msg->len) > + break; > + > + idx = idx + len; > + if ((msg->len - sent) < 60) > + len = msg->len - sent; > + else > + len = 60; > + > + /* > + * Testing shows delay is needed between successive writes > + * otherwise next write fails on first-try from i2c core. > + * This value is obtained through automated stress testing. > + */ > + usleep_range(980, 1000); > + } while (len > 0); > + > + return ret; > +} > + > +/* > + * Device reads all data (0 - 65535 bytes) from i2c slave device and > + * stores it in device itself. This data is read back from device to > + * host in multiples of 60 bytes using input reports. > + */ > +static int mcp_i2c_smbus_read(struct mcp2221 *mcp, > + struct i2c_msg *msg, int type, u16 smbus_addr, > + u8 smbus_len, u8 *smbus_buf) > +{ > + int ret; > + u16 total_len; > + > + mcp->txbuf[0] = type; > + if (msg) { > + mcp->txbuf[1] = msg->len & 0xff; > + mcp->txbuf[2] = msg->len >> 8; > + mcp->txbuf[3] = (u8)(msg->addr << 1); > + total_len = msg->len; > + mcp->rxbuf = msg->buf; > + } else { > + mcp->txbuf[1] = smbus_len; > + mcp->txbuf[2] = 0; > + mcp->txbuf[3] = (u8)(smbus_addr << 1); > + total_len = smbus_len; > + mcp->rxbuf = smbus_buf; > + } > + > + ret = mcp_send_data_req_status(mcp, mcp->txbuf, 4); > + if (ret) > + return ret; > + > + mcp->rxbuf_idx = 0; > + > + do { > + memset(mcp->txbuf, 0, 4); > + mcp->txbuf[0] = MCP2221_I2C_GET_DATA; > + > + ret = mcp_send_data_req_status(mcp, mcp->txbuf, 1); > + if (ret) > + return ret; > + > + ret = mcp_chk_last_cmd_status(mcp); > + if (ret) > + return ret; > + > + usleep_range(980, 1000); > + } while (mcp->rxbuf_idx < total_len); > + > + return ret; > +} > + > +static int mcp_i2c_xfer(struct i2c_adapter *adapter, > + struct i2c_msg msgs[], int num) > +{ > + int ret; > + struct mcp2221 *mcp = i2c_get_adapdata(adapter); > + > + hid_hw_power(mcp->hdev, PM_HINT_FULLON); > + > + mutex_lock(&mcp->lock); > + > + /* Setting speed before every transaction is required for mcp2221 */ > + ret = mcp_set_i2c_speed(mcp); > + if (ret) > + goto exit; > + > + if (num == 1) { > + if (msgs->flags & I2C_M_RD) { > + ret = mcp_i2c_smbus_read(mcp, msgs, MCP2221_I2C_RD_DATA, > + 0, 0, NULL); > + } else { > + ret = mcp_i2c_write(mcp, msgs, MCP2221_I2C_WR_DATA, 1); > + } > + if (ret) > + goto exit; > + ret = num; > + } else if (num == 2) { > + /* Ex transaction; send reg address and read its contents */ > + if (msgs[0].addr == msgs[1].addr && > + !(msgs[0].flags & I2C_M_RD) && > + (msgs[1].flags & I2C_M_RD)) { > + > + ret = mcp_i2c_write(mcp, &msgs[0], > + MCP2221_I2C_WR_NO_STOP, 0); > + if (ret) > + goto exit; > + > + ret = mcp_i2c_smbus_read(mcp, &msgs[1], > + MCP2221_I2C_RD_RPT_START, > + 0, 0, NULL); > + if (ret) > + goto exit; > + ret = num; > + } else { > + dev_err(&adapter->dev, > + "unsupported multi-msg i2c transaction\n"); > + ret = -EOPNOTSUPP; > + } > + } else { > + dev_err(&adapter->dev, > + "unsupported multi-msg i2c transaction\n"); > + ret = -EOPNOTSUPP; > + } > + > +exit: > + hid_hw_power(mcp->hdev, PM_HINT_NORMAL); > + mutex_unlock(&mcp->lock); > + return ret; > +} > + > +static int mcp_smbus_write(struct mcp2221 *mcp, u16 addr, > + u8 command, u8 *buf, u8 len, int type, > + u8 last_status) > +{ > + int data_len, ret; > + > + mcp->txbuf[0] = type; > + mcp->txbuf[1] = len + 1; /* 1 is due to command byte itself */ > + mcp->txbuf[2] = 0; > + mcp->txbuf[3] = (u8)(addr << 1); > + mcp->txbuf[4] = command; > + > + switch (len) { > + case 0: > + data_len = 5; > + break; > + case 1: > + mcp->txbuf[5] = buf[0]; > + data_len = 6; > + break; > + case 2: > + mcp->txbuf[5] = buf[0]; > + mcp->txbuf[6] = buf[1]; > + data_len = 7; > + break; > + default: > + memcpy(&mcp->txbuf[5], buf, len); > + data_len = len + 5; > + } > + > + ret = mcp_send_data_req_status(mcp, mcp->txbuf, data_len); > + if (ret) > + return ret; > + > + if (last_status) { > + usleep_range(980, 1000); > + > + ret = mcp_chk_last_cmd_status(mcp); > + if (ret) > + return ret; > + } > + > + return ret; > +} > + > +static int mcp_smbus_xfer(struct i2c_adapter *adapter, u16 addr, > + unsigned short flags, char read_write, > + u8 command, int size, > + union i2c_smbus_data *data) > +{ > + int ret; > + struct mcp2221 *mcp = i2c_get_adapdata(adapter); > + > + hid_hw_power(mcp->hdev, PM_HINT_FULLON); > + > + mutex_lock(&mcp->lock); > + > + ret = mcp_set_i2c_speed(mcp); > + if (ret) > + goto exit; > + > + switch (size) { > + > + case I2C_SMBUS_QUICK: > + if (read_write == I2C_SMBUS_READ) > + ret = mcp_i2c_smbus_read(mcp, NULL, MCP2221_I2C_RD_DATA, > + addr, 0, &data->byte); > + else > + ret = mcp_smbus_write(mcp, addr, command, NULL, > + 0, MCP2221_I2C_WR_DATA, 1); > + break; > + case I2C_SMBUS_BYTE: > + if (read_write == I2C_SMBUS_READ) > + ret = mcp_i2c_smbus_read(mcp, NULL, MCP2221_I2C_RD_DATA, > + addr, 1, &data->byte); > + else > + ret = mcp_smbus_write(mcp, addr, command, NULL, > + 0, MCP2221_I2C_WR_DATA, 1); > + break; > + case I2C_SMBUS_BYTE_DATA: > + if (read_write == I2C_SMBUS_READ) { > + ret = mcp_smbus_write(mcp, addr, command, NULL, > + 0, MCP2221_I2C_WR_NO_STOP, 0); > + if (ret) > + goto exit; > + > + ret = mcp_i2c_smbus_read(mcp, NULL, > + MCP2221_I2C_RD_RPT_START, > + addr, 1, &data->byte); > + } else { > + ret = mcp_smbus_write(mcp, addr, command, &data->byte, > + 1, MCP2221_I2C_WR_DATA, 1); > + } > + break; > + case I2C_SMBUS_WORD_DATA: > + if (read_write == I2C_SMBUS_READ) { > + ret = mcp_smbus_write(mcp, addr, command, NULL, > + 0, MCP2221_I2C_WR_NO_STOP, 0); > + if (ret) > + goto exit; > + > + ret = mcp_i2c_smbus_read(mcp, NULL, > + MCP2221_I2C_RD_RPT_START, > + addr, 2, (u8 *)&data->word); > + } else { > + ret = mcp_smbus_write(mcp, addr, command, > + (u8 *)&data->word, 2, > + MCP2221_I2C_WR_DATA, 1); > + } > + break; > + case I2C_SMBUS_BLOCK_DATA: > + if (read_write == I2C_SMBUS_READ) { > + ret = mcp_smbus_write(mcp, addr, command, NULL, > + 0, MCP2221_I2C_WR_NO_STOP, 1); > + if (ret) > + goto exit; > + > + mcp->rxbuf_idx = 0; > + mcp->rxbuf = data->block; > + mcp->txbuf[0] = MCP2221_I2C_GET_DATA; > + ret = mcp_send_data_req_status(mcp, mcp->txbuf, 1); > + if (ret) > + goto exit; > + } else { > + if (!data->block[0]) { > + ret = -EINVAL; > + goto exit; > + } > + ret = mcp_smbus_write(mcp, addr, command, data->block, > + data->block[0] + 1, > + MCP2221_I2C_WR_DATA, 1); > + } > + break; > + case I2C_SMBUS_I2C_BLOCK_DATA: > + if (read_write == I2C_SMBUS_READ) { > + ret = mcp_smbus_write(mcp, addr, command, NULL, > + 0, MCP2221_I2C_WR_NO_STOP, 1); > + if (ret) > + goto exit; > + > + mcp->rxbuf_idx = 0; > + mcp->rxbuf = data->block; > + mcp->txbuf[0] = MCP2221_I2C_GET_DATA; > + ret = mcp_send_data_req_status(mcp, mcp->txbuf, 1); > + if (ret) > + goto exit; > + } else { > + if (!data->block[0]) { > + ret = -EINVAL; > + goto exit; > + } > + ret = mcp_smbus_write(mcp, addr, command, > + &data->block[1], data->block[0], > + MCP2221_I2C_WR_DATA, 1); > + } > + break; > + case I2C_SMBUS_PROC_CALL: > + ret = mcp_smbus_write(mcp, addr, command, > + (u8 *)&data->word, > + 2, MCP2221_I2C_WR_NO_STOP, 0); > + if (ret) > + goto exit; > + > + ret = mcp_i2c_smbus_read(mcp, NULL, > + MCP2221_I2C_RD_RPT_START, > + addr, 2, (u8 *)&data->word); > + break; > + case I2C_SMBUS_BLOCK_PROC_CALL: > + ret = mcp_smbus_write(mcp, addr, command, data->block, > + data->block[0] + 1, > + MCP2221_I2C_WR_NO_STOP, 0); > + if (ret) > + goto exit; > + > + ret = mcp_i2c_smbus_read(mcp, NULL, > + MCP2221_I2C_RD_RPT_START, > + addr, I2C_SMBUS_BLOCK_MAX, > + data->block); > + break; > + default: > + dev_err(&mcp->adapter.dev, > + "unsupported smbus transaction size:%d\n", size); > + ret = -EOPNOTSUPP; > + } > + > +exit: > + hid_hw_power(mcp->hdev, PM_HINT_NORMAL); > + mutex_unlock(&mcp->lock); > + return ret; > +} > + > +static u32 mcp_i2c_func(struct i2c_adapter *adapter) > +{ > + return I2C_FUNC_I2C | > + I2C_FUNC_SMBUS_READ_BLOCK_DATA | > + I2C_FUNC_SMBUS_BLOCK_PROC_CALL | > + (I2C_FUNC_SMBUS_EMUL & ~I2C_FUNC_SMBUS_PEC); > +} > + > +static const struct i2c_algorithm mcp_i2c_algo = { > + .master_xfer = mcp_i2c_xfer, > + .smbus_xfer = mcp_smbus_xfer, > + .functionality = mcp_i2c_func, > +}; > + > +/* Gives current state of i2c engine inside mcp2221 */ > +static int mcp_get_i2c_eng_state(struct mcp2221 *mcp, > + u8 *data, u8 idx) > +{ > + int ret; > + > + switch (data[idx]) { > + case MCP2221_I2C_WRADDRL_NACK: > + case MCP2221_I2C_WRADDRL_SEND: > + ret = -ENXIO; > + break; > + case MCP2221_I2C_START_TOUT: > + case MCP2221_I2C_STOP_TOUT: > + case MCP2221_I2C_WRADDRL_TOUT: > + case MCP2221_I2C_WRDATA_TOUT: > + ret = -ETIMEDOUT; > + break; > + case MCP2221_I2C_ENG_BUSY: > + ret = -EAGAIN; > + break; > + case MCP2221_SUCCESS: > + ret = 0x00; > + break; > + default: > + ret = -EIO; > + } > + > + return ret; > +} > + > +/* > + * MCP2221 uses interrupt endpoint for input reports. This function > + * is called by HID layer when it receives i/p report from mcp2221, > + * which is actually a response to the previously sent command. > + * > + * MCP2221A firmware specific return codes are parsed and 0 or > + * appropriate negative error code is returned. Delayed response > + * results in timeout error and stray reponses results in -EIO. > + */ > +static int mcp2221_raw_event(struct hid_device *hdev, > + struct hid_report *report, u8 *data, int size) > +{ > + u8 *buf; > + struct mcp2221 *mcp = hid_get_drvdata(hdev); > + > + switch (data[0]) { > + > + case MCP2221_I2C_WR_DATA: > + case MCP2221_I2C_WR_NO_STOP: > + case MCP2221_I2C_RD_DATA: > + case MCP2221_I2C_RD_RPT_START: > + switch (data[1]) { > + case MCP2221_SUCCESS: > + mcp->status = 0; > + break; > + default: > + mcp->status = mcp_get_i2c_eng_state(mcp, data, 2); > + } > + complete(&mcp->wait_in_report); > + break; > + > + case MCP2221_I2C_PARAM_OR_STATUS: > + switch (data[1]) { > + case MCP2221_SUCCESS: > + if ((mcp->txbuf[3] == MCP2221_I2C_SET_SPEED) && > + (data[3] != MCP2221_I2C_SET_SPEED)) { > + mcp->status = -EAGAIN; > + break; > + } > + if (data[20] & MCP2221_I2C_MASK_ADDR_NACK) { > + mcp->status = -ENXIO; > + break; > + } > + mcp->status = mcp_get_i2c_eng_state(mcp, data, 8); > + break; > + default: > + mcp->status = -EIO; > + } > + complete(&mcp->wait_in_report); > + break; > + > + case MCP2221_I2C_GET_DATA: > + switch (data[1]) { > + case MCP2221_SUCCESS: > + if (data[2] == MCP2221_I2C_ADDR_NACK) { > + mcp->status = -ENXIO; > + break; > + } > + if (!mcp_get_i2c_eng_state(mcp, data, 2) > + && (data[3] == 0)) { > + mcp->status = 0; > + break; > + } > + if (data[3] == 127) { > + mcp->status = -EIO; > + break; > + } > + if (data[2] == MCP2221_I2C_READ_COMPL) { > + buf = mcp->rxbuf; > + memcpy(&buf[mcp->rxbuf_idx], &data[4], data[3]); > + mcp->rxbuf_idx = mcp->rxbuf_idx + data[3]; > + mcp->status = 0; > + break; > + } > + mcp->status = -EIO; > + break; > + default: > + mcp->status = -EIO; > + } > + complete(&mcp->wait_in_report); > + break; > + > + default: > + mcp->status = -EIO; > + complete(&mcp->wait_in_report); > + } > + > + return 1; > +} > + > +static int mcp2221_probe(struct hid_device *hdev, > + const struct hid_device_id *id) > +{ > + int ret; > + struct mcp2221 *mcp; > + > + mcp = devm_kzalloc(&hdev->dev, sizeof(*mcp), GFP_KERNEL); > + if (!mcp) > + return -ENOMEM; > + > + ret = hid_parse(hdev); > + if (ret) { > + hid_err(hdev, "can't parse reports\n"); > + return ret; > + } > + > + ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW); > + if (ret) { > + hid_err(hdev, "can't start hardware\n"); > + return ret; > + } > + > + ret = hid_hw_open(hdev); > + if (ret) { > + hid_err(hdev, "can't open device\n"); > + goto err_hstop; > + } > + > + mutex_init(&mcp->lock); > + init_completion(&mcp->wait_in_report); > + hid_set_drvdata(hdev, mcp); > + mcp->hdev = hdev; > + > + /* Set I2C bus clock diviser */ > + if (i2c_clk_freq > 400) > + i2c_clk_freq = 400; > + if (i2c_clk_freq < 50) > + i2c_clk_freq = 50; > + mcp->cur_i2c_clk_div = (12000000 / (i2c_clk_freq * 1000)) - 3; > + > + mcp->adapter.owner = THIS_MODULE; > + mcp->adapter.class = I2C_CLASS_HWMON; > + mcp->adapter.algo = &mcp_i2c_algo; > + mcp->adapter.retries = 1; > + mcp->adapter.dev.parent = &hdev->dev; > + snprintf(mcp->adapter.name, sizeof(mcp->adapter.name), > + "MCP2221 usb-i2c bridge on hidraw%d", > + ((struct hidraw *)hdev->hidraw)->minor); > + > + ret = i2c_add_adapter(&mcp->adapter); > + if (ret) { > + hid_err(hdev, "can't add usb-i2c adapter: %d\n", ret); > + goto err_i2c; > + } > + i2c_set_adapdata(&mcp->adapter, mcp); > + > + return 0; > + > +err_i2c: > + hid_hw_close(mcp->hdev); > +err_hstop: > + hid_hw_stop(mcp->hdev); > + return ret; > +} > + > +static void mcp2221_remove(struct hid_device *hdev) > +{ > + struct mcp2221 *mcp = hid_get_drvdata(hdev); > + > + i2c_del_adapter(&mcp->adapter); > + hid_hw_close(mcp->hdev); > + hid_hw_stop(mcp->hdev); > +} > + > +static const struct hid_device_id mcp2221_devices[] = { > + { HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_MCP2221) }, > + { } > +}; > +MODULE_DEVICE_TABLE(hid, mcp2221_devices); > + > +static struct hid_driver mcp2221_driver = { > + .name = "mcp2221", > + .id_table = mcp2221_devices, > + .probe = mcp2221_probe, > + .remove = mcp2221_remove, > + .raw_event = mcp2221_raw_event, > +}; > + > +/* Register with HID core */ > +module_hid_driver(mcp2221_driver); > + > +MODULE_AUTHOR("Rishi Gupta "); > +MODULE_DESCRIPTION("MCP2221 Microchip HID USB to I2C master bridge"); > +MODULE_LICENSE("GPL v2"); > -- > 2.7.4 >