rmi4/rmi_smbus.c

   1 /*
   2  * Copyright (c) 2015 - 2016 Red Hat, Inc
   3  * Copyright (c) 2011, 2012 Synaptics Incorporated
   4  * Copyright (c) 2011 Unixphere
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License version 2 as published by
   8  * the Free Software Foundation.
   9  */
  10
  11 #include <linux/kernel.h>
  12 #include <linux/delay.h>
  13 #include <linux/i2c.h>
  14 #include <linux/interrupt.h>
  15 #include <linux/kconfig.h>
  16 #include <linux/lockdep.h>
  17 #include <linux/module.h>
  18 #include <linux/pm.h>
  19 #include <linux/rmi.h>
  20 #include <linux/slab.h>
  21 #include "rmi_driver.h"
  22
  23 #define SMB_PROTOCOL_VERSION_ADDRESS    0xfd
  24 #define SMB_MAX_COUNT                   32
  25 #define RMI_SMB2_MAP_SIZE               8 /* 8 entry of 4 bytes each */
  26 #define RMI_SMB2_MAP_FLAGS_WE           0x01
  27
  28 struct mapping_table_entry {
  29         __le16 rmiaddr;
  30         u8 readcount;
  31         u8 flags;
  32 };
  33
  34 struct rmi_smb_xport {
  35         struct rmi_transport_dev xport;
  36         struct i2c_client *client;
  37
  38         struct mutex page_mutex;
  39         int page;
  40         u8 table_index;
  41         struct mutex mappingtable_mutex;
  42         struct mapping_table_entry mapping_table[RMI_SMB2_MAP_SIZE];
  43 };
  44
  45 static int rmi_smb_get_version(struct rmi_smb_xport *rmi_smb)
  46 {
  47         struct i2c_client *client = rmi_smb->client;
  48         int retval;
  49
  50         /* Check if for SMBus new version device by reading version byte. */
  51         retval = i2c_smbus_read_byte_data(client, SMB_PROTOCOL_VERSION_ADDRESS);
  52         if (retval < 0) {
  53                 dev_err(&client->dev, "failed to get SMBus version number!\n");
  54                 return retval;
  55         }
  56
  57         return retval + 1;
  58 }
  59
  60 /* SMB block write - wrapper over ic2_smb_write_block */
  61 static int smb_block_write(struct rmi_transport_dev *xport,
  62                               u8 commandcode, const void *buf, size_t len)
  63 {
  64         struct rmi_smb_xport *rmi_smb =
  65                 container_of(xport, struct rmi_smb_xport, xport);
  66         struct i2c_client *client = rmi_smb->client;
  67         int retval;
  68
  69         retval = i2c_smbus_write_block_data(client, commandcode, len, buf);
  70
  71         rmi_dbg(RMI_DEBUG_XPORT, &client->dev,
  72                 "wrote %zd bytes at %#04x: %d (%*ph)\n",
  73                 len, commandcode, retval, (int)len, buf);
  74
  75         return retval;
  76 }
  77
  78 /*
  79  * The function to get command code for smbus operations and keeps
  80  * records to the driver mapping table
  81  */
  82 static int rmi_smb_get_command_code(struct rmi_transport_dev *xport,
  83                 u16 rmiaddr, int bytecount, bool isread, u8 *commandcode)
  84 {
  85         struct rmi_smb_xport *rmi_smb =
  86                 container_of(xport, struct rmi_smb_xport, xport);
  87         struct mapping_table_entry new_map;
  88         int i;
  89         int retval = 0;
  90
  91         mutex_lock(&rmi_smb->mappingtable_mutex);
  92
  93         for (i = 0; i < RMI_SMB2_MAP_SIZE; i++) {
  94                 struct mapping_table_entry *entry = &rmi_smb->mapping_table[i];
  95
  96                 if (le16_to_cpu(entry->rmiaddr) == rmiaddr) {
  97                         if (isread) {
  98                                 if (entry->readcount == bytecount)
  99                                         goto exit;
 100                         } else {
 101                                 if (entry->flags & RMI_SMB2_MAP_FLAGS_WE) {
 102                                         goto exit;
 103                                 }
 104                         }
 105                 }
 106         }
 107
 108         i = rmi_smb->table_index;
 109         rmi_smb->table_index = (i + 1) % RMI_SMB2_MAP_SIZE;
 110
 111         /* constructs mapping table data entry. 4 bytes each entry */
 112         memset(&new_map, 0, sizeof(new_map));
 113         new_map.rmiaddr = cpu_to_le16(rmiaddr);
 114         new_map.readcount = bytecount;
 115         new_map.flags = !isread ? RMI_SMB2_MAP_FLAGS_WE : 0;
 116
 117         retval = smb_block_write(xport, i + 0x80, &new_map, sizeof(new_map));
 118         if (retval < 0) {
 119                 /*
 120                  * if not written to device mapping table
 121                  * clear the driver mapping table records
 122                  */
 123                 memset(&new_map, 0, sizeof(new_map));
 124         }
 125
 126         /* save to the driver level mapping table */
 127         rmi_smb->mapping_table[i] = new_map;
 128
 129 exit:
 130         mutex_unlock(&rmi_smb->mappingtable_mutex);
 131
 132         if (retval < 0)
 133                 return retval;
 134
 135         *commandcode = i;
 136         return 0;
 137 }
 138
 139 static int rmi_smb_write_block(struct rmi_transport_dev *xport, u16 rmiaddr,
 140                                 const void *databuff, size_t len)
 141 {
 142         int retval = 0;
 143         u8 commandcode;
 144         struct rmi_smb_xport *rmi_smb =
 145                 container_of(xport, struct rmi_smb_xport, xport);
 146         int cur_len = (int)len;
 147
 148         mutex_lock(&rmi_smb->page_mutex);
 149
 150         while (cur_len > 0) {
 151                 /*
 152                  * break into 32 bytes chunks to write get command code
 153                  */
 154                 int block_len = min_t(int, len, SMB_MAX_COUNT);
 155
 156                 retval = rmi_smb_get_command_code(xport, rmiaddr, block_len,
 157                                                   false, &commandcode);
 158                 if (retval < 0)
 159                         goto exit;
 160
 161                 retval = smb_block_write(xport, commandcode,
 162                                          databuff, block_len);
 163                 if (retval < 0)
 164                         goto exit;
 165
 166                 /* prepare to write next block of bytes */
 167                 cur_len -= SMB_MAX_COUNT;
 168                 databuff += SMB_MAX_COUNT;
 169                 rmiaddr += SMB_MAX_COUNT;
 170         }
 171 exit:
 172         mutex_unlock(&rmi_smb->page_mutex);
 173         return retval;
 174 }
 175
 176 /* SMB block read - wrapper over ic2_smb_read_block */
 177 static int smb_block_read(struct rmi_transport_dev *xport,
 178                              u8 commandcode, void *buf, size_t len)
 179 {
 180         struct rmi_smb_xport *rmi_smb =
 181                 container_of(xport, struct rmi_smb_xport, xport);
 182         struct i2c_client *client = rmi_smb->client;
 183         int retval;
 184
 185         retval = i2c_smbus_read_block_data(client, commandcode, buf);
 186         if (retval < 0)
 187                 return retval;
 188
 189         return retval;
 190 }
 191
 192 static int rmi_smb_read_block(struct rmi_transport_dev *xport, u16 rmiaddr,
 193                               void *databuff, size_t len)
 194 {
 195         struct rmi_smb_xport *rmi_smb =
 196                 container_of(xport, struct rmi_smb_xport, xport);
 197         int retval;
 198         u8 commandcode;
 199         int cur_len = (int)len;
 200
 201         mutex_lock(&rmi_smb->page_mutex);
 202         memset(databuff, 0, len);
 203
 204         while (cur_len > 0) {
 205                 /* break into 32 bytes chunks to write get command code */
 206                 int block_len =  min_t(int, cur_len, SMB_MAX_COUNT);
 207
 208                 retval = rmi_smb_get_command_code(xport, rmiaddr, block_len,
 209                                                   true, &commandcode);
 210                 if (retval < 0)
 211                         goto exit;
 212
 213                 retval = smb_block_read(xport, commandcode,
 214                                         databuff, block_len);
 215                 if (retval < 0)
 216                         goto exit;
 217
 218                 /* prepare to read next block of bytes */
 219                 cur_len -= SMB_MAX_COUNT;
 220                 databuff += SMB_MAX_COUNT;
 221                 rmiaddr += SMB_MAX_COUNT;
 222         }
 223
 224         retval = 0;
 225
 226 exit:
 227         mutex_unlock(&rmi_smb->page_mutex);
 228         return retval;
 229 }
 230
 231 static void rmi_smb_clear_state(struct rmi_smb_xport *rmi_smb)
 232 {
 233         /* the mapping table has been flushed, discard the current one */
 234         mutex_lock(&rmi_smb->mappingtable_mutex);
 235         memset(rmi_smb->mapping_table, 0, sizeof(rmi_smb->mapping_table));
 236         mutex_unlock(&rmi_smb->mappingtable_mutex);
 237 }
 238
 239 static int rmi_smb_enable_smbus_mode(struct rmi_smb_xport *rmi_smb)
 240 {
 241         struct i2c_client *client = rmi_smb->client;
 242         int smbus_version;
 243
 244         /*
 245          * psmouse driver resets the controller, we only need to wait
 246          * to give the firmware chance to fully reinitialize.
 247          */
 248         if (rmi_smb->xport.pdata.reset_delay_ms)
 249                 msleep(rmi_smb->xport.pdata.reset_delay_ms);
 250
 251         /* we need to get the smbus version to activate the touchpad */
 252         smbus_version = rmi_smb_get_version(rmi_smb);
 253         if (smbus_version < 0)
 254                 return smbus_version;
 255
 256         rmi_dbg(RMI_DEBUG_XPORT, &client->dev, "Smbus version is %d",
 257                 smbus_version);
 258
 259         if (smbus_version != 2 && smbus_version != 3) {
 260                 dev_err(&client->dev, "Unrecognized SMB version %d\n",
 261                                 smbus_version);
 262                 return -ENODEV;
 263         }
 264
 265         return 0;
 266 }
 267
 268 static int rmi_smb_reset(struct rmi_transport_dev *xport, u16 reset_addr)
 269 {
 270         struct rmi_smb_xport *rmi_smb =
 271                 container_of(xport, struct rmi_smb_xport, xport);
 272
 273         rmi_smb_clear_state(rmi_smb);
 274
 275         /*
 276          * We do not call the actual reset command, it has to be handled in
 277          * PS/2 or there will be races between PS/2 and SMBus. PS/2 should
 278          * ensure that a psmouse_reset is called before initializing the
 279          * device and after it has been removed to be in a known state.
 280          */
 281         return rmi_smb_enable_smbus_mode(rmi_smb);
 282 }
 283
 284 static const struct rmi_transport_ops rmi_smb_ops = {
 285         .write_block    = rmi_smb_write_block,
 286         .read_block     = rmi_smb_read_block,
 287         .reset          = rmi_smb_reset,
 288 };
 289
 290 static int rmi_smb_probe(struct i2c_client *client,
 291                          const struct i2c_device_id *id)
 292 {
 293         struct rmi_device_platform_data *pdata = dev_get_platdata(&client->dev);
 294         struct rmi_smb_xport *rmi_smb;
 295         int error;
 296
 297         if (!pdata) {
 298                 dev_err(&client->dev, "no platform data, aborting\n");
 299                 return -ENOMEM;
 300         }
 301
 302         if (!i2c_check_functionality(client->adapter,
 303                                      I2C_FUNC_SMBUS_READ_BLOCK_DATA |
 304                                      I2C_FUNC_SMBUS_HOST_NOTIFY)) {
 305                 dev_err(&client->dev,
 306                         "adapter does not support required functionality\n");
 307                 return -ENODEV;
 308         }
 309
 310         if (client->irq <= 0) {
 311                 dev_err(&client->dev, "no IRQ provided, giving up\n");
 312                 return client->irq ? client->irq : -ENODEV;
 313         }
 314
 315         rmi_smb = devm_kzalloc(&client->dev, sizeof(struct rmi_smb_xport),
 316                                 GFP_KERNEL);
 317         if (!rmi_smb)
 318                 return -ENOMEM;
 319
 320         rmi_dbg(RMI_DEBUG_XPORT, &client->dev, "Probing %s\n",
 321                 dev_name(&client->dev));
 322
 323         rmi_smb->client = client;
 324         mutex_init(&rmi_smb->page_mutex);
 325         mutex_init(&rmi_smb->mappingtable_mutex);
 326
 327         rmi_smb->xport.dev = &client->dev;
 328         rmi_smb->xport.pdata = *pdata;
 329         rmi_smb->xport.pdata.irq = client->irq;
 330         rmi_smb->xport.proto_name = "smb";
 331         rmi_smb->xport.ops = &rmi_smb_ops;
 332
 333         error = rmi_smb_enable_smbus_mode(rmi_smb);
 334         if (error)
 335                 return error;
 336
 337         i2c_set_clientdata(client, rmi_smb);
 338
 339         dev_info(&client->dev, "registering SMbus-connected sensor\n");
 340
 341         error = rmi_register_transport_device(&rmi_smb->xport);
 342         if (error) {
 343                 dev_err(&client->dev, "failed to register sensor: %d\n", error);
 344                 return error;
 345         }
 346
 347         return 0;
 348 }
 349
 350 static int rmi_smb_remove(struct i2c_client *client)
 351 {
 352         struct rmi_smb_xport *rmi_smb = i2c_get_clientdata(client);
 353
 354         rmi_unregister_transport_device(&rmi_smb->xport);
 355
 356         return 0;
 357 }
 358
 359 static int __maybe_unused rmi_smb_suspend(struct device *dev)
 360 {
 361         struct i2c_client *client = to_i2c_client(dev);
 362         struct rmi_smb_xport *rmi_smb = i2c_get_clientdata(client);
 363         int ret;
 364
 365         ret = rmi_driver_suspend(rmi_smb->xport.rmi_dev, true);
 366         if (ret)
 367                 dev_warn(dev, "Failed to suspend device: %d\n", ret);
 368
 369         return ret;
 370 }
 371
 372 static int __maybe_unused rmi_smb_runtime_suspend(struct device *dev)
 373 {
 374         struct i2c_client *client = to_i2c_client(dev);
 375         struct rmi_smb_xport *rmi_smb = i2c_get_clientdata(client);
 376         int ret;
 377
 378         ret = rmi_driver_suspend(rmi_smb->xport.rmi_dev, false);
 379         if (ret)
 380                 dev_warn(dev, "Failed to suspend device: %d\n", ret);
 381
 382         return ret;
 383 }
 384
 385 static int __maybe_unused rmi_smb_resume(struct device *dev)
 386 {
 387         struct i2c_client *client = container_of(dev, struct i2c_client, dev);
 388         struct rmi_smb_xport *rmi_smb = i2c_get_clientdata(client);
 389         struct rmi_device *rmi_dev = rmi_smb->xport.rmi_dev;
 390         int ret;
 391
 392         rmi_smb_reset(&rmi_smb->xport, 0);
 393
 394         rmi_reset(rmi_dev);
 395
 396         ret = rmi_driver_resume(rmi_smb->xport.rmi_dev, true);
 397         if (ret)
 398                 dev_warn(dev, "Failed to resume device: %d\n", ret);
 399
 400         return 0;
 401 }
 402
 403 static int __maybe_unused rmi_smb_runtime_resume(struct device *dev)
 404 {
 405         struct i2c_client *client = to_i2c_client(dev);
 406         struct rmi_smb_xport *rmi_smb = i2c_get_clientdata(client);
 407         int ret;
 408
 409         ret = rmi_driver_resume(rmi_smb->xport.rmi_dev, false);
 410         if (ret)
 411                 dev_warn(dev, "Failed to resume device: %d\n", ret);
 412
 413         return 0;
 414 }
 415
 416 static const struct dev_pm_ops rmi_smb_pm = {
 417         SET_SYSTEM_SLEEP_PM_OPS(rmi_smb_suspend, rmi_smb_resume)
 418         SET_RUNTIME_PM_OPS(rmi_smb_runtime_suspend, rmi_smb_runtime_resume,
 419                            NULL)
 420 };
 421
 422 static const struct i2c_device_id rmi_id[] = {
 423         { "rmi4_smbus", 0 },
 424         { }
 425 };
 426 MODULE_DEVICE_TABLE(i2c, rmi_id);
 427
 428 static struct i2c_driver rmi_smb_driver = {
 429         .driver = {
 430                 .name   = "rmi4_smbus",
 431                 .pm     = &rmi_smb_pm,
 432         },
 433         .id_table       = rmi_id,
 434         .probe          = rmi_smb_probe,
 435         .remove         = rmi_smb_remove,
 436 };
 437
 438 module_i2c_driver(rmi_smb_driver);
 439
 440 MODULE_AUTHOR("Andrew Duggan <aduggan@synaptics.com>");
 441 MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@redhat.com>");
 442 MODULE_DESCRIPTION("RMI4 SMBus driver");
 443 MODULE_LICENSE("GPL");