input/rmi4/rmi_smbus.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Copyright (c) 2015 - 2016 Red Hat, Inc
0004  * Copyright (c) 2011, 2012 Synaptics Incorporated
0005  * Copyright (c) 2011 Unixphere
0006  */
0007
0008 #include <linux/kernel.h>
0009 #include <linux/delay.h>
0010 #include <linux/i2c.h>
0011 #include <linux/interrupt.h>
0012 #include <linux/kconfig.h>
0013 #include <linux/lockdep.h>
0014 #include <linux/module.h>
0015 #include <linux/pm.h>
0016 #include <linux/rmi.h>
0017 #include <linux/slab.h>
0018 #include "rmi_driver.h"
0019
0020 #define SMB_PROTOCOL_VERSION_ADDRESS    0xfd
0021 #define SMB_MAX_COUNT           32
0022 #define RMI_SMB2_MAP_SIZE       8 /* 8 entry of 4 bytes each */
0023 #define RMI_SMB2_MAP_FLAGS_WE       0x01
0024
0025 struct mapping_table_entry {
0026     __le16 rmiaddr;
0027     u8 readcount;
0028     u8 flags;
0029 };
0030
0031 struct rmi_smb_xport {
0032     struct rmi_transport_dev xport;
0033     struct i2c_client *client;
0034
0035     struct mutex page_mutex;
0036     int page;
0037     u8 table_index;
0038     struct mutex mappingtable_mutex;
0039     struct mapping_table_entry mapping_table[RMI_SMB2_MAP_SIZE];
0040 };
0041
0042 static int rmi_smb_get_version(struct rmi_smb_xport *rmi_smb)
0043 {
0044     struct i2c_client *client = rmi_smb->client;
0045     int retval;
0046
0047     /* Check if for SMBus new version device by reading version byte. */
0048     retval = i2c_smbus_read_byte_data(client, SMB_PROTOCOL_VERSION_ADDRESS);
0049     if (retval < 0) {
0050         dev_err(&client->dev, "failed to get SMBus version number!\n");
0051         return retval;
0052     }
0053
0054     return retval + 1;
0055 }
0056
0057 /* SMB block write - wrapper over ic2_smb_write_block */
0058 static int smb_block_write(struct rmi_transport_dev *xport,
0059                   u8 commandcode, const void *buf, size_t len)
0060 {
0061     struct rmi_smb_xport *rmi_smb =
0062         container_of(xport, struct rmi_smb_xport, xport);
0063     struct i2c_client *client = rmi_smb->client;
0064     int retval;
0065
0066     retval = i2c_smbus_write_block_data(client, commandcode, len, buf);
0067
0068     rmi_dbg(RMI_DEBUG_XPORT, &client->dev,
0069         "wrote %zd bytes at %#04x: %d (%*ph)\n",
0070         len, commandcode, retval, (int)len, buf);
0071
0072     return retval;
0073 }
0074
0075 /*
0076  * The function to get command code for smbus operations and keeps
0077  * records to the driver mapping table
0078  */
0079 static int rmi_smb_get_command_code(struct rmi_transport_dev *xport,
0080         u16 rmiaddr, int bytecount, bool isread, u8 *commandcode)
0081 {
0082     struct rmi_smb_xport *rmi_smb =
0083         container_of(xport, struct rmi_smb_xport, xport);
0084     struct mapping_table_entry new_map;
0085     int i;
0086     int retval = 0;
0087
0088     mutex_lock(&rmi_smb->mappingtable_mutex);
0089
0090     for (i = 0; i < RMI_SMB2_MAP_SIZE; i++) {
0091         struct mapping_table_entry *entry = &rmi_smb->mapping_table[i];
0092
0093         if (le16_to_cpu(entry->rmiaddr) == rmiaddr) {
0094             if (isread) {
0095                 if (entry->readcount == bytecount)
0096                     goto exit;
0097             } else {
0098                 if (entry->flags & RMI_SMB2_MAP_FLAGS_WE) {
0099                     goto exit;
0100                 }
0101             }
0102         }
0103     }
0104
0105     i = rmi_smb->table_index;
0106     rmi_smb->table_index = (i + 1) % RMI_SMB2_MAP_SIZE;
0107
0108     /* constructs mapping table data entry. 4 bytes each entry */
0109     memset(&new_map, 0, sizeof(new_map));
0110     new_map.rmiaddr = cpu_to_le16(rmiaddr);
0111     new_map.readcount = bytecount;
0112     new_map.flags = !isread ? RMI_SMB2_MAP_FLAGS_WE : 0;
0113
0114     retval = smb_block_write(xport, i + 0x80, &new_map, sizeof(new_map));
0115     if (retval < 0) {
0116         /*
0117          * if not written to device mapping table
0118          * clear the driver mapping table records
0119          */
0120         memset(&new_map, 0, sizeof(new_map));
0121     }
0122
0123     /* save to the driver level mapping table */
0124     rmi_smb->mapping_table[i] = new_map;
0125
0126 exit:
0127     mutex_unlock(&rmi_smb->mappingtable_mutex);
0128
0129     if (retval < 0)
0130         return retval;
0131
0132     *commandcode = i;
0133     return 0;
0134 }
0135
0136 static int rmi_smb_write_block(struct rmi_transport_dev *xport, u16 rmiaddr,
0137                 const void *databuff, size_t len)
0138 {
0139     int retval = 0;
0140     u8 commandcode;
0141     struct rmi_smb_xport *rmi_smb =
0142         container_of(xport, struct rmi_smb_xport, xport);
0143     int cur_len = (int)len;
0144
0145     mutex_lock(&rmi_smb->page_mutex);
0146
0147     while (cur_len > 0) {
0148         /*
0149          * break into 32 bytes chunks to write get command code
0150          */
0151         int block_len = min_t(int, len, SMB_MAX_COUNT);
0152
0153         retval = rmi_smb_get_command_code(xport, rmiaddr, block_len,
0154                           false, &commandcode);
0155         if (retval < 0)
0156             goto exit;
0157
0158         retval = smb_block_write(xport, commandcode,
0159                      databuff, block_len);
0160         if (retval < 0)
0161             goto exit;
0162
0163         /* prepare to write next block of bytes */
0164         cur_len -= SMB_MAX_COUNT;
0165         databuff += SMB_MAX_COUNT;
0166         rmiaddr += SMB_MAX_COUNT;
0167     }
0168 exit:
0169     mutex_unlock(&rmi_smb->page_mutex);
0170     return retval;
0171 }
0172
0173 /* SMB block read - wrapper over ic2_smb_read_block */
0174 static int smb_block_read(struct rmi_transport_dev *xport,
0175                  u8 commandcode, void *buf, size_t len)
0176 {
0177     struct rmi_smb_xport *rmi_smb =
0178         container_of(xport, struct rmi_smb_xport, xport);
0179     struct i2c_client *client = rmi_smb->client;
0180     int retval;
0181
0182     retval = i2c_smbus_read_block_data(client, commandcode, buf);
0183     if (retval < 0)
0184         return retval;
0185
0186     return retval;
0187 }
0188
0189 static int rmi_smb_read_block(struct rmi_transport_dev *xport, u16 rmiaddr,
0190                   void *databuff, size_t len)
0191 {
0192     struct rmi_smb_xport *rmi_smb =
0193         container_of(xport, struct rmi_smb_xport, xport);
0194     int retval;
0195     u8 commandcode;
0196     int cur_len = (int)len;
0197
0198     mutex_lock(&rmi_smb->page_mutex);
0199     memset(databuff, 0, len);
0200
0201     while (cur_len > 0) {
0202         /* break into 32 bytes chunks to write get command code */
0203         int block_len =  min_t(int, cur_len, SMB_MAX_COUNT);
0204
0205         retval = rmi_smb_get_command_code(xport, rmiaddr, block_len,
0206                           true, &commandcode);
0207         if (retval < 0)
0208             goto exit;
0209
0210         retval = smb_block_read(xport, commandcode,
0211                     databuff, block_len);
0212         if (retval < 0)
0213             goto exit;
0214
0215         /* prepare to read next block of bytes */
0216         cur_len -= SMB_MAX_COUNT;
0217         databuff += SMB_MAX_COUNT;
0218         rmiaddr += SMB_MAX_COUNT;
0219     }
0220
0221     retval = 0;
0222
0223 exit:
0224     mutex_unlock(&rmi_smb->page_mutex);
0225     return retval;
0226 }
0227
0228 static void rmi_smb_clear_state(struct rmi_smb_xport *rmi_smb)
0229 {
0230     /* the mapping table has been flushed, discard the current one */
0231     mutex_lock(&rmi_smb->mappingtable_mutex);
0232     memset(rmi_smb->mapping_table, 0, sizeof(rmi_smb->mapping_table));
0233     mutex_unlock(&rmi_smb->mappingtable_mutex);
0234 }
0235
0236 static int rmi_smb_enable_smbus_mode(struct rmi_smb_xport *rmi_smb)
0237 {
0238     int retval;
0239
0240     /* we need to get the smbus version to activate the touchpad */
0241     retval = rmi_smb_get_version(rmi_smb);
0242     if (retval < 0)
0243         return retval;
0244
0245     return 0;
0246 }
0247
0248 static int rmi_smb_reset(struct rmi_transport_dev *xport, u16 reset_addr)
0249 {
0250     struct rmi_smb_xport *rmi_smb =
0251         container_of(xport, struct rmi_smb_xport, xport);
0252
0253     rmi_smb_clear_state(rmi_smb);
0254
0255     /*
0256      * we do not call the actual reset command, it has to be handled in
0257      * PS/2 or there will be races between PS/2 and SMBus.
0258      * PS/2 should ensure that a psmouse_reset is called before
0259      * intializing the device and after it has been removed to be in a known
0260      * state.
0261      */
0262     return rmi_smb_enable_smbus_mode(rmi_smb);
0263 }
0264
0265 static const struct rmi_transport_ops rmi_smb_ops = {
0266     .write_block    = rmi_smb_write_block,
0267     .read_block = rmi_smb_read_block,
0268     .reset      = rmi_smb_reset,
0269 };
0270
0271 static int rmi_smb_probe(struct i2c_client *client,
0272              const struct i2c_device_id *id)
0273 {
0274     struct rmi_device_platform_data *pdata = dev_get_platdata(&client->dev);
0275     struct rmi_smb_xport *rmi_smb;
0276     int smbus_version;
0277     int error;
0278
0279     if (!pdata) {
0280         dev_err(&client->dev, "no platform data, aborting\n");
0281         return -ENOMEM;
0282     }
0283
0284     if (!i2c_check_functionality(client->adapter,
0285                      I2C_FUNC_SMBUS_READ_BLOCK_DATA |
0286                      I2C_FUNC_SMBUS_HOST_NOTIFY)) {
0287         dev_err(&client->dev,
0288             "adapter does not support required functionality\n");
0289         return -ENODEV;
0290     }
0291
0292     if (client->irq <= 0) {
0293         dev_err(&client->dev, "no IRQ provided, giving up\n");
0294         return client->irq ? client->irq : -ENODEV;
0295     }
0296
0297     rmi_smb = devm_kzalloc(&client->dev, sizeof(struct rmi_smb_xport),
0298                 GFP_KERNEL);
0299     if (!rmi_smb)
0300         return -ENOMEM;
0301
0302     rmi_dbg(RMI_DEBUG_XPORT, &client->dev, "Probing %s\n",
0303         dev_name(&client->dev));
0304
0305     rmi_smb->client = client;
0306     mutex_init(&rmi_smb->page_mutex);
0307     mutex_init(&rmi_smb->mappingtable_mutex);
0308
0309     rmi_smb->xport.dev = &client->dev;
0310     rmi_smb->xport.pdata = *pdata;
0311     rmi_smb->xport.pdata.irq = client->irq;
0312     rmi_smb->xport.proto_name = "smb";
0313     rmi_smb->xport.ops = &rmi_smb_ops;
0314
0315     smbus_version = rmi_smb_get_version(rmi_smb);
0316     if (smbus_version < 0)
0317         return smbus_version;
0318
0319     rmi_dbg(RMI_DEBUG_XPORT, &client->dev, "Smbus version is %d",
0320         smbus_version);
0321
0322     if (smbus_version != 2 && smbus_version != 3) {
0323         dev_err(&client->dev, "Unrecognized SMB version %d\n",
0324                 smbus_version);
0325         return -ENODEV;
0326     }
0327
0328     i2c_set_clientdata(client, rmi_smb);
0329
0330     dev_info(&client->dev, "registering SMbus-connected sensor\n");
0331
0332     error = rmi_register_transport_device(&rmi_smb->xport);
0333     if (error) {
0334         dev_err(&client->dev, "failed to register sensor: %d\n", error);
0335         return error;
0336     }
0337
0338     return 0;
0339 }
0340
0341 static int rmi_smb_remove(struct i2c_client *client)
0342 {
0343     struct rmi_smb_xport *rmi_smb = i2c_get_clientdata(client);
0344
0345     rmi_unregister_transport_device(&rmi_smb->xport);
0346
0347     return 0;
0348 }
0349
0350 static int __maybe_unused rmi_smb_suspend(struct device *dev)
0351 {
0352     struct i2c_client *client = to_i2c_client(dev);
0353     struct rmi_smb_xport *rmi_smb = i2c_get_clientdata(client);
0354     int ret;
0355
0356     ret = rmi_driver_suspend(rmi_smb->xport.rmi_dev, true);
0357     if (ret)
0358         dev_warn(dev, "Failed to suspend device: %d\n", ret);
0359
0360     return ret;
0361 }
0362
0363 static int __maybe_unused rmi_smb_runtime_suspend(struct device *dev)
0364 {
0365     struct i2c_client *client = to_i2c_client(dev);
0366     struct rmi_smb_xport *rmi_smb = i2c_get_clientdata(client);
0367     int ret;
0368
0369     ret = rmi_driver_suspend(rmi_smb->xport.rmi_dev, false);
0370     if (ret)
0371         dev_warn(dev, "Failed to suspend device: %d\n", ret);
0372
0373     return ret;
0374 }
0375
0376 static int __maybe_unused rmi_smb_resume(struct device *dev)
0377 {
0378     struct i2c_client *client = container_of(dev, struct i2c_client, dev);
0379     struct rmi_smb_xport *rmi_smb = i2c_get_clientdata(client);
0380     struct rmi_device *rmi_dev = rmi_smb->xport.rmi_dev;
0381     int ret;
0382
0383     rmi_smb_reset(&rmi_smb->xport, 0);
0384
0385     rmi_reset(rmi_dev);
0386
0387     ret = rmi_driver_resume(rmi_smb->xport.rmi_dev, true);
0388     if (ret)
0389         dev_warn(dev, "Failed to resume device: %d\n", ret);
0390
0391     return 0;
0392 }
0393
0394 static int __maybe_unused rmi_smb_runtime_resume(struct device *dev)
0395 {
0396     struct i2c_client *client = to_i2c_client(dev);
0397     struct rmi_smb_xport *rmi_smb = i2c_get_clientdata(client);
0398     int ret;
0399
0400     ret = rmi_driver_resume(rmi_smb->xport.rmi_dev, false);
0401     if (ret)
0402         dev_warn(dev, "Failed to resume device: %d\n", ret);
0403
0404     return 0;
0405 }
0406
0407 static const struct dev_pm_ops rmi_smb_pm = {
0408     SET_SYSTEM_SLEEP_PM_OPS(rmi_smb_suspend, rmi_smb_resume)
0409     SET_RUNTIME_PM_OPS(rmi_smb_runtime_suspend, rmi_smb_runtime_resume,
0410                NULL)
0411 };
0412
0413 static const struct i2c_device_id rmi_id[] = {
0414     { "rmi4_smbus", 0 },
0415     { }
0416 };
0417 MODULE_DEVICE_TABLE(i2c, rmi_id);
0418
0419 static struct i2c_driver rmi_smb_driver = {
0420     .driver = {
0421         .name   = "rmi4_smbus",
0422         .pm = &rmi_smb_pm,
0423     },
0424     .id_table   = rmi_id,
0425     .probe      = rmi_smb_probe,
0426     .remove     = rmi_smb_remove,
0427 };
0428
0429 module_i2c_driver(rmi_smb_driver);
0430
0431 MODULE_AUTHOR("Andrew Duggan <aduggan@synaptics.com>");
0432 MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@redhat.com>");
0433 MODULE_DESCRIPTION("RMI4 SMBus driver");
0434 MODULE_LICENSE("GPL");