i2c/busses/i2c-tegra-bpmp.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * drivers/i2c/busses/i2c-tegra-bpmp.c
0004  *
0005  * Copyright (c) 2016 NVIDIA Corporation.  All rights reserved.
0006  *
0007  * Author: Shardar Shariff Md <smohammed@nvidia.com>
0008  */
0009
0010 #include <linux/err.h>
0011 #include <linux/i2c.h>
0012 #include <linux/init.h>
0013 #include <linux/kernel.h>
0014 #include <linux/module.h>
0015 #include <linux/of_device.h>
0016 #include <linux/platform_device.h>
0017 #include <linux/pm_runtime.h>
0018
0019 #include <soc/tegra/bpmp-abi.h>
0020 #include <soc/tegra/bpmp.h>
0021
0022 /*
0023  * Serialized I2C message header size is 6 bytes and includes address, flags
0024  * and length
0025  */
0026 #define SERIALI2C_HDR_SIZE 6
0027
0028 struct tegra_bpmp_i2c {
0029     struct i2c_adapter adapter;
0030     struct device *dev;
0031
0032     struct tegra_bpmp *bpmp;
0033     unsigned int bus;
0034 };
0035
0036 /*
0037  * Linux flags are translated to BPMP defined I2C flags that are used in BPMP
0038  * firmware I2C driver to avoid any issues in future if Linux I2C flags are
0039  * changed.
0040  */
0041 static void tegra_bpmp_xlate_flags(u16 flags, u16 *out)
0042 {
0043     if (flags & I2C_M_TEN)
0044         *out |= SERIALI2C_TEN;
0045
0046     if (flags & I2C_M_RD)
0047         *out |= SERIALI2C_RD;
0048
0049     if (flags & I2C_M_STOP)
0050         *out |= SERIALI2C_STOP;
0051
0052     if (flags & I2C_M_NOSTART)
0053         *out |= SERIALI2C_NOSTART;
0054
0055     if (flags & I2C_M_REV_DIR_ADDR)
0056         *out |= SERIALI2C_REV_DIR_ADDR;
0057
0058     if (flags & I2C_M_IGNORE_NAK)
0059         *out |= SERIALI2C_IGNORE_NAK;
0060
0061     if (flags & I2C_M_NO_RD_ACK)
0062         *out |= SERIALI2C_NO_RD_ACK;
0063
0064     if (flags & I2C_M_RECV_LEN)
0065         *out |= SERIALI2C_RECV_LEN;
0066 }
0067
0068 /*
0069  * The serialized I2C format is simply the following:
0070  * [addr little-endian][flags little-endian][len little-endian][data if write]
0071  * [addr little-endian][flags little-endian][len little-endian][data if write]
0072  *  ...
0073  *
0074  * The flags are translated from Linux kernel representation to seriali2c
0075  * representation. Any undefined flag being set causes an error.
0076  *
0077  * The data is there only for writes. Reads have the data transferred in the
0078  * other direction, and thus data is not present.
0079  *
0080  * See deserialize_i2c documentation for the data format in the other direction.
0081  */
0082 static void tegra_bpmp_serialize_i2c_msg(struct tegra_bpmp_i2c *i2c,
0083                     struct mrq_i2c_request *request,
0084                     struct i2c_msg *msgs,
0085                     unsigned int num)
0086 {
0087     char *buf = request->xfer.data_buf;
0088     unsigned int i, j, pos = 0;
0089
0090     for (i = 0; i < num; i++) {
0091         struct i2c_msg *msg = &msgs[i];
0092         u16 flags = 0;
0093
0094         tegra_bpmp_xlate_flags(msg->flags, &flags);
0095
0096         buf[pos++] = msg->addr & 0xff;
0097         buf[pos++] = (msg->addr & 0xff00) >> 8;
0098         buf[pos++] = flags & 0xff;
0099         buf[pos++] = (flags & 0xff00) >> 8;
0100         buf[pos++] = msg->len & 0xff;
0101         buf[pos++] = (msg->len & 0xff00) >> 8;
0102
0103         if ((flags & SERIALI2C_RD) == 0) {
0104             for (j = 0; j < msg->len; j++)
0105                 buf[pos++] = msg->buf[j];
0106         }
0107     }
0108
0109     request->xfer.data_size = pos;
0110 }
0111
0112 /*
0113  * The data in the BPMP -> CPU direction is composed of sequential blocks for
0114  * those messages that have I2C_M_RD. So, for example, if you have:
0115  *
0116  * - !I2C_M_RD, len == 5, data == a0 01 02 03 04
0117  * - !I2C_M_RD, len == 1, data == a0
0118  * - I2C_M_RD, len == 2, data == [uninitialized buffer 1]
0119  * - !I2C_M_RD, len == 1, data == a2
0120  * - I2C_M_RD, len == 2, data == [uninitialized buffer 2]
0121  *
0122  * ...then the data in the BPMP -> CPU direction would be 4 bytes total, and
0123  * would contain 2 bytes that will go to uninitialized buffer 1, and 2 bytes
0124  * that will go to uninitialized buffer 2.
0125  */
0126 static int tegra_bpmp_i2c_deserialize(struct tegra_bpmp_i2c *i2c,
0127                       struct mrq_i2c_response *response,
0128                       struct i2c_msg *msgs,
0129                       unsigned int num)
0130 {
0131     size_t size = response->xfer.data_size, len = 0, pos = 0;
0132     char *buf = response->xfer.data_buf;
0133     unsigned int i;
0134
0135     for (i = 0; i < num; i++)
0136         if (msgs[i].flags & I2C_M_RD)
0137             len += msgs[i].len;
0138
0139     if (len != size)
0140         return -EINVAL;
0141
0142     for (i = 0; i < num; i++) {
0143         if (msgs[i].flags & I2C_M_RD) {
0144             memcpy(msgs[i].buf, buf + pos, msgs[i].len);
0145             pos += msgs[i].len;
0146         }
0147     }
0148
0149     return 0;
0150 }
0151
0152 static int tegra_bpmp_i2c_msg_len_check(struct i2c_msg *msgs, unsigned int num)
0153 {
0154     size_t tx_len = 0, rx_len = 0;
0155     unsigned int i;
0156
0157     for (i = 0; i < num; i++)
0158         if (!(msgs[i].flags & I2C_M_RD))
0159             tx_len += SERIALI2C_HDR_SIZE + msgs[i].len;
0160
0161     if (tx_len > TEGRA_I2C_IPC_MAX_IN_BUF_SIZE)
0162         return -EINVAL;
0163
0164     for (i = 0; i < num; i++)
0165         if ((msgs[i].flags & I2C_M_RD))
0166             rx_len += msgs[i].len;
0167
0168     if (rx_len > TEGRA_I2C_IPC_MAX_OUT_BUF_SIZE)
0169         return -EINVAL;
0170
0171     return 0;
0172 }
0173
0174 static int tegra_bpmp_i2c_msg_xfer(struct tegra_bpmp_i2c *i2c,
0175                    struct mrq_i2c_request *request,
0176                    struct mrq_i2c_response *response,
0177                    bool atomic)
0178 {
0179     struct tegra_bpmp_message msg;
0180     int err;
0181
0182     request->cmd = CMD_I2C_XFER;
0183     request->xfer.bus_id = i2c->bus;
0184
0185     memset(&msg, 0, sizeof(msg));
0186     msg.mrq = MRQ_I2C;
0187     msg.tx.data = request;
0188     msg.tx.size = sizeof(*request);
0189     msg.rx.data = response;
0190     msg.rx.size = sizeof(*response);
0191
0192     if (atomic)
0193         err = tegra_bpmp_transfer_atomic(i2c->bpmp, &msg);
0194     else
0195         err = tegra_bpmp_transfer(i2c->bpmp, &msg);
0196
0197     if (err < 0) {
0198         dev_err(i2c->dev, "failed to transfer message: %d\n", err);
0199         return err;
0200     }
0201
0202     if (msg.rx.ret != 0) {
0203         if (msg.rx.ret == -BPMP_EAGAIN) {
0204             dev_dbg(i2c->dev, "arbitration lost\n");
0205             return -EAGAIN;
0206         }
0207
0208         if (msg.rx.ret == -BPMP_ETIMEDOUT) {
0209             dev_dbg(i2c->dev, "timeout\n");
0210             return -ETIMEDOUT;
0211         }
0212
0213         if (msg.rx.ret == -BPMP_ENXIO) {
0214             dev_dbg(i2c->dev, "NAK\n");
0215             return -ENXIO;
0216         }
0217
0218         dev_err(i2c->dev, "transaction failed: %d\n", msg.rx.ret);
0219         return -EIO;
0220     }
0221
0222     return 0;
0223 }
0224
0225 static int tegra_bpmp_i2c_xfer_common(struct i2c_adapter *adapter,
0226                       struct i2c_msg *msgs, int num,
0227                       bool atomic)
0228 {
0229     struct tegra_bpmp_i2c *i2c = i2c_get_adapdata(adapter);
0230     struct mrq_i2c_response response;
0231     struct mrq_i2c_request request;
0232     int err;
0233
0234     err = tegra_bpmp_i2c_msg_len_check(msgs, num);
0235     if (err < 0) {
0236         dev_err(i2c->dev, "unsupported message length\n");
0237         return err;
0238     }
0239
0240     memset(&request, 0, sizeof(request));
0241     memset(&response, 0, sizeof(response));
0242
0243     tegra_bpmp_serialize_i2c_msg(i2c, &request, msgs, num);
0244     err = tegra_bpmp_i2c_msg_xfer(i2c, &request, &response, atomic);
0245     if (err < 0) {
0246         dev_err(i2c->dev, "failed to transfer message: %d\n", err);
0247         return err;
0248     }
0249
0250     err = tegra_bpmp_i2c_deserialize(i2c, &response, msgs, num);
0251     if (err < 0) {
0252         dev_err(i2c->dev, "failed to deserialize message: %d\n", err);
0253         return err;
0254     }
0255
0256     return num;
0257 }
0258
0259 static int tegra_bpmp_i2c_xfer(struct i2c_adapter *adapter,
0260                    struct i2c_msg *msgs, int num)
0261 {
0262     return tegra_bpmp_i2c_xfer_common(adapter, msgs, num, false);
0263 }
0264
0265 static int tegra_bpmp_i2c_xfer_atomic(struct i2c_adapter *adapter,
0266                       struct i2c_msg *msgs, int num)
0267 {
0268     return tegra_bpmp_i2c_xfer_common(adapter, msgs, num, true);
0269 }
0270
0271 static u32 tegra_bpmp_i2c_func(struct i2c_adapter *adapter)
0272 {
0273     return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL | I2C_FUNC_10BIT_ADDR |
0274            I2C_FUNC_PROTOCOL_MANGLING | I2C_FUNC_NOSTART;
0275 }
0276
0277 static const struct i2c_algorithm tegra_bpmp_i2c_algo = {
0278     .master_xfer = tegra_bpmp_i2c_xfer,
0279     .master_xfer_atomic = tegra_bpmp_i2c_xfer_atomic,
0280     .functionality = tegra_bpmp_i2c_func,
0281 };
0282
0283 static int tegra_bpmp_i2c_probe(struct platform_device *pdev)
0284 {
0285     struct tegra_bpmp_i2c *i2c;
0286     u32 value;
0287     int err;
0288
0289     i2c = devm_kzalloc(&pdev->dev, sizeof(*i2c), GFP_KERNEL);
0290     if (!i2c)
0291         return -ENOMEM;
0292
0293     i2c->dev = &pdev->dev;
0294
0295     i2c->bpmp = dev_get_drvdata(pdev->dev.parent);
0296     if (!i2c->bpmp)
0297         return -ENODEV;
0298
0299     err = of_property_read_u32(pdev->dev.of_node, "nvidia,bpmp-bus-id",
0300                    &value);
0301     if (err < 0)
0302         return err;
0303
0304     i2c->bus = value;
0305
0306     i2c_set_adapdata(&i2c->adapter, i2c);
0307     i2c->adapter.owner = THIS_MODULE;
0308     strscpy(i2c->adapter.name, "Tegra BPMP I2C adapter",
0309         sizeof(i2c->adapter.name));
0310     i2c->adapter.algo = &tegra_bpmp_i2c_algo;
0311     i2c->adapter.dev.parent = &pdev->dev;
0312     i2c->adapter.dev.of_node = pdev->dev.of_node;
0313
0314     platform_set_drvdata(pdev, i2c);
0315
0316     return i2c_add_adapter(&i2c->adapter);
0317 }
0318
0319 static int tegra_bpmp_i2c_remove(struct platform_device *pdev)
0320 {
0321     struct tegra_bpmp_i2c *i2c = platform_get_drvdata(pdev);
0322
0323     i2c_del_adapter(&i2c->adapter);
0324
0325     return 0;
0326 }
0327
0328 static const struct of_device_id tegra_bpmp_i2c_of_match[] = {
0329     { .compatible = "nvidia,tegra186-bpmp-i2c", },
0330     { }
0331 };
0332 MODULE_DEVICE_TABLE(of, tegra_bpmp_i2c_of_match);
0333
0334 static struct platform_driver tegra_bpmp_i2c_driver = {
0335     .driver = {
0336         .name = "tegra-bpmp-i2c",
0337         .of_match_table = tegra_bpmp_i2c_of_match,
0338     },
0339     .probe = tegra_bpmp_i2c_probe,
0340     .remove = tegra_bpmp_i2c_remove,
0341 };
0342 module_platform_driver(tegra_bpmp_i2c_driver);
0343
0344 MODULE_DESCRIPTION("NVIDIA Tegra BPMP I2C bus controller driver");
0345 MODULE_AUTHOR("Shardar Shariff Md <smohammed@nvidia.com>");
0346 MODULE_AUTHOR("Juha-Matti Tilli");
0347 MODULE_LICENSE("GPL v2");