drivers/input/rmi4/rmi_i2c.c

   1 /*
   2  * Copyright (c) 2011-2016 Synaptics Incorporated
   3  * Copyright (c) 2011 Unixphere
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 as published by
   7  * the Free Software Foundation.
   8  */
   9
  10 #include <linux/i2c.h>
  11 #include <linux/rmi.h>
  12 #include <linux/irq.h>
  13 #include <linux/of.h>
  14 #include <linux/delay.h>
  15 #include <linux/regulator/consumer.h>
  16 #include "rmi_driver.h"
  17
  18 #define BUFFER_SIZE_INCREMENT 32
  19
  20 /**
  21  * struct rmi_i2c_xport - stores information for i2c communication
  22  *
  23  * @xport: The transport interface structure
  24  *
  25  * @page_mutex: Locks current page to avoid changing pages in unexpected ways.
  26  * @page: Keeps track of the current virtual page
  27  *
  28  * @tx_buf: Buffer used for transmitting data to the sensor over i2c.
  29  * @tx_buf_size: Size of the buffer
  30  */
  31 struct rmi_i2c_xport {
  32         struct rmi_transport_dev xport;
  33         struct i2c_client *client;
  34
  35         struct mutex page_mutex;
  36         int page;
  37
  38         int irq;
  39
  40         u8 *tx_buf;
  41         size_t tx_buf_size;
  42
  43         struct regulator_bulk_data supplies[2];
  44         u32 startup_delay;
  45 };
  46
  47 #define RMI_PAGE_SELECT_REGISTER 0xff
  48 #define RMI_I2C_PAGE(addr) (((addr) >> 8) & 0xff)
  49
  50 /*
  51  * rmi_set_page - Set RMI page
  52  * @xport: The pointer to the rmi_transport_dev struct
  53  * @page: The new page address.
  54  *
  55  * RMI devices have 16-bit addressing, but some of the transport
  56  * implementations (like SMBus) only have 8-bit addressing. So RMI implements
  57  * a page address at 0xff of every page so we can reliable page addresses
  58  * every 256 registers.
  59  *
  60  * The page_mutex lock must be held when this function is entered.
  61  *
  62  * Returns zero on success, non-zero on failure.
  63  */
  64 static int rmi_set_page(struct rmi_i2c_xport *rmi_i2c, u8 page)
  65 {
  66         struct i2c_client *client = rmi_i2c->client;
  67         u8 txbuf[2] = {RMI_PAGE_SELECT_REGISTER, page};
  68         int retval;
  69
  70         retval = i2c_master_send(client, txbuf, sizeof(txbuf));
  71         if (retval != sizeof(txbuf)) {
  72                 dev_err(&client->dev,
  73                         "%s: set page failed: %d.", __func__, retval);
  74                 return (retval < 0) ? retval : -EIO;
  75         }
  76
  77         rmi_i2c->page = page;
  78         return 0;
  79 }
  80
  81 static int rmi_i2c_write_block(struct rmi_transport_dev *xport, u16 addr,
  82                                const void *buf, size_t len)
  83 {
  84         struct rmi_i2c_xport *rmi_i2c =
  85                 container_of(xport, struct rmi_i2c_xport, xport);
  86         struct i2c_client *client = rmi_i2c->client;
  87         size_t tx_size = len + 1;
  88         int retval;
  89
  90         mutex_lock(&rmi_i2c->page_mutex);
  91
  92         if (!rmi_i2c->tx_buf || rmi_i2c->tx_buf_size < tx_size) {
  93                 if (rmi_i2c->tx_buf)
  94                         devm_kfree(&client->dev, rmi_i2c->tx_buf);
  95                 rmi_i2c->tx_buf_size = tx_size + BUFFER_SIZE_INCREMENT;
  96                 rmi_i2c->tx_buf = devm_kzalloc(&client->dev,
  97                                                rmi_i2c->tx_buf_size,
  98                                                GFP_KERNEL);
  99                 if (!rmi_i2c->tx_buf) {
 100                         rmi_i2c->tx_buf_size = 0;
 101                         retval = -ENOMEM;
 102                         goto exit;
 103                 }
 104         }
 105
 106         rmi_i2c->tx_buf[0] = addr & 0xff;
 107         memcpy(rmi_i2c->tx_buf + 1, buf, len);
 108
 109         if (RMI_I2C_PAGE(addr) != rmi_i2c->page) {
 110                 retval = rmi_set_page(rmi_i2c, RMI_I2C_PAGE(addr));
 111                 if (retval)
 112                         goto exit;
 113         }
 114
 115         retval = i2c_master_send(client, rmi_i2c->tx_buf, tx_size);
 116         if (retval == tx_size)
 117                 retval = 0;
 118         else if (retval >= 0)
 119                 retval = -EIO;
 120
 121 exit:
 122         rmi_dbg(RMI_DEBUG_XPORT, &client->dev,
 123                 "write %zd bytes at %#06x: %d (%*ph)\n",
 124                 len, addr, retval, (int)len, buf);
 125
 126         mutex_unlock(&rmi_i2c->page_mutex);
 127         return retval;
 128 }
 129
 130 static int rmi_i2c_read_block(struct rmi_transport_dev *xport, u16 addr,
 131                               void *buf, size_t len)
 132 {
 133         struct rmi_i2c_xport *rmi_i2c =
 134                 container_of(xport, struct rmi_i2c_xport, xport);
 135         struct i2c_client *client = rmi_i2c->client;
 136         u8 addr_offset = addr & 0xff;
 137         int retval;
 138         struct i2c_msg msgs[] = {
 139                 {
 140                         .addr   = client->addr,
 141                         .len    = sizeof(addr_offset),
 142                         .buf    = &addr_offset,
 143                 },
 144                 {
 145                         .addr   = client->addr,
 146                         .flags  = I2C_M_RD,
 147                         .len    = len,
 148                         .buf    = buf,
 149                 },
 150         };
 151
 152         mutex_lock(&rmi_i2c->page_mutex);
 153
 154         if (RMI_I2C_PAGE(addr) != rmi_i2c->page) {
 155                 retval = rmi_set_page(rmi_i2c, RMI_I2C_PAGE(addr));
 156                 if (retval)
 157                         goto exit;
 158         }
 159
 160         retval = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
 161         if (retval == ARRAY_SIZE(msgs))
 162                 retval = 0; /* success */
 163         else if (retval >= 0)
 164                 retval = -EIO;
 165
 166 exit:
 167         rmi_dbg(RMI_DEBUG_XPORT, &client->dev,
 168                 "read %zd bytes at %#06x: %d (%*ph)\n",
 169                 len, addr, retval, (int)len, buf);
 170
 171         mutex_unlock(&rmi_i2c->page_mutex);
 172         return retval;
 173 }
 174
 175 static const struct rmi_transport_ops rmi_i2c_ops = {
 176         .write_block    = rmi_i2c_write_block,
 177         .read_block     = rmi_i2c_read_block,
 178 };
 179
 180 static irqreturn_t rmi_i2c_irq(int irq, void *dev_id)
 181 {
 182         struct rmi_i2c_xport *rmi_i2c = dev_id;
 183         struct rmi_device *rmi_dev = rmi_i2c->xport.rmi_dev;
 184         int ret;
 185
 186         ret = rmi_process_interrupt_requests(rmi_dev);
 187         if (ret)
 188                 rmi_dbg(RMI_DEBUG_XPORT, &rmi_dev->dev,
 189                         "Failed to process interrupt request: %d\n", ret);
 190
 191         return IRQ_HANDLED;
 192 }
 193
 194 static int rmi_i2c_init_irq(struct i2c_client *client)
 195 {
 196         struct rmi_i2c_xport *rmi_i2c = i2c_get_clientdata(client);
 197         int irq_flags = irqd_get_trigger_type(irq_get_irq_data(rmi_i2c->irq));
 198         int ret;
 199
 200         if (!irq_flags)
 201                 irq_flags = IRQF_TRIGGER_LOW;
 202
 203         ret = devm_request_threaded_irq(&client->dev, rmi_i2c->irq, NULL,
 204                         rmi_i2c_irq, irq_flags | IRQF_ONESHOT, client->name,
 205                         rmi_i2c);
 206         if (ret < 0) {
 207                 dev_warn(&client->dev, "Failed to register interrupt %d\n",
 208                         rmi_i2c->irq);
 209
 210                 return ret;
 211         }
 212
 213         return 0;
 214 }
 215
 216 #ifdef CONFIG_OF
 217 static const struct of_device_id rmi_i2c_of_match[] = {
 218         { .compatible = "syna,rmi4-i2c" },
 219         {},
 220 };
 221 MODULE_DEVICE_TABLE(of, rmi_i2c_of_match);
 222 #endif
 223
 224 static int rmi_i2c_probe(struct i2c_client *client,
 225                          const struct i2c_device_id *id)
 226 {
 227         struct rmi_device_platform_data *pdata;
 228         struct rmi_device_platform_data *client_pdata =
 229                                         dev_get_platdata(&client->dev);
 230         struct rmi_i2c_xport *rmi_i2c;
 231         int retval;
 232
 233         rmi_i2c = devm_kzalloc(&client->dev, sizeof(struct rmi_i2c_xport),
 234                                 GFP_KERNEL);
 235         if (!rmi_i2c)
 236                 return -ENOMEM;
 237
 238         pdata = &rmi_i2c->xport.pdata;
 239
 240         if (!client->dev.of_node && client_pdata)
 241                 *pdata = *client_pdata;
 242
 243         if (client->irq > 0)
 244                 rmi_i2c->irq = client->irq;
 245
 246         rmi_dbg(RMI_DEBUG_XPORT, &client->dev, "Probing %s.\n",
 247                         dev_name(&client->dev));
 248         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
 249                 dev_err(&client->dev,
 250                         "adapter does not support required functionality.\n");
 251                 return -ENODEV;
 252         }
 253
 254         rmi_i2c->supplies[0].supply = "vdd";
 255         rmi_i2c->supplies[1].supply = "vio";
 256         retval = devm_regulator_bulk_get(&client->dev,
 257                                          ARRAY_SIZE(rmi_i2c->supplies),
 258                                          rmi_i2c->supplies);
 259         if (retval < 0)
 260                 return retval;
 261
 262         retval = regulator_bulk_enable(ARRAY_SIZE(rmi_i2c->supplies),
 263                                        rmi_i2c->supplies);
 264         if (retval < 0)
 265                 return retval;
 266
 267         of_property_read_u32(client->dev.of_node, "syna,startup-delay-ms",
 268                              &rmi_i2c->startup_delay);
 269
 270         msleep(rmi_i2c->startup_delay);
 271
 272         rmi_i2c->client = client;
 273         mutex_init(&rmi_i2c->page_mutex);
 274
 275         rmi_i2c->xport.dev = &client->dev;
 276         rmi_i2c->xport.proto_name = "i2c";
 277         rmi_i2c->xport.ops = &rmi_i2c_ops;
 278
 279         i2c_set_clientdata(client, rmi_i2c);
 280
 281         /*
 282          * Setting the page to zero will (a) make sure the PSR is in a
 283          * known state, and (b) make sure we can talk to the device.
 284          */
 285         retval = rmi_set_page(rmi_i2c, 0);
 286         if (retval) {
 287                 dev_err(&client->dev, "Failed to set page select to 0.\n");
 288                 return retval;
 289         }
 290
 291         retval = rmi_register_transport_device(&rmi_i2c->xport);
 292         if (retval) {
 293                 dev_err(&client->dev, "Failed to register transport driver at 0x%.2X.\n",
 294                         client->addr);
 295                 return retval;
 296         }
 297
 298         retval = rmi_i2c_init_irq(client);
 299         if (retval < 0)
 300                 return retval;
 301
 302         dev_info(&client->dev, "registered rmi i2c driver at %#04x.\n",
 303                         client->addr);
 304         return 0;
 305 }
 306
 307 static int rmi_i2c_remove(struct i2c_client *client)
 308 {
 309         struct rmi_i2c_xport *rmi_i2c = i2c_get_clientdata(client);
 310
 311         rmi_unregister_transport_device(&rmi_i2c->xport);
 312         regulator_bulk_disable(ARRAY_SIZE(rmi_i2c->supplies),
 313                                rmi_i2c->supplies);
 314
 315         return 0;
 316 }
 317
 318 #ifdef CONFIG_PM_SLEEP
 319 static int rmi_i2c_suspend(struct device *dev)
 320 {
 321         struct i2c_client *client = to_i2c_client(dev);
 322         struct rmi_i2c_xport *rmi_i2c = i2c_get_clientdata(client);
 323         int ret;
 324
 325         ret = rmi_driver_suspend(rmi_i2c->xport.rmi_dev);
 326         if (ret)
 327                 dev_warn(dev, "Failed to resume device: %d\n", ret);
 328
 329         disable_irq(rmi_i2c->irq);
 330         if (device_may_wakeup(&client->dev)) {
 331                 ret = enable_irq_wake(rmi_i2c->irq);
 332                 if (!ret)
 333                         dev_warn(dev, "Failed to enable irq for wake: %d\n",
 334                                 ret);
 335         }
 336
 337         regulator_bulk_disable(ARRAY_SIZE(rmi_i2c->supplies),
 338                                rmi_i2c->supplies);
 339
 340         return ret;
 341 }
 342
 343 static int rmi_i2c_resume(struct device *dev)
 344 {
 345         struct i2c_client *client = to_i2c_client(dev);
 346         struct rmi_i2c_xport *rmi_i2c = i2c_get_clientdata(client);
 347         int ret;
 348
 349         ret = regulator_bulk_enable(ARRAY_SIZE(rmi_i2c->supplies),
 350                                     rmi_i2c->supplies);
 351         if (ret)
 352                 return ret;
 353
 354         msleep(rmi_i2c->startup_delay);
 355
 356         enable_irq(rmi_i2c->irq);
 357         if (device_may_wakeup(&client->dev)) {
 358                 ret = disable_irq_wake(rmi_i2c->irq);
 359                 if (!ret)
 360                         dev_warn(dev, "Failed to disable irq for wake: %d\n",
 361                                 ret);
 362         }
 363
 364         ret = rmi_driver_resume(rmi_i2c->xport.rmi_dev);
 365         if (ret)
 366                 dev_warn(dev, "Failed to resume device: %d\n", ret);
 367
 368         return ret;
 369 }
 370 #endif
 371
 372 #ifdef CONFIG_PM
 373 static int rmi_i2c_runtime_suspend(struct device *dev)
 374 {
 375         struct i2c_client *client = to_i2c_client(dev);
 376         struct rmi_i2c_xport *rmi_i2c = i2c_get_clientdata(client);
 377         int ret;
 378
 379         ret = rmi_driver_suspend(rmi_i2c->xport.rmi_dev);
 380         if (ret)
 381                 dev_warn(dev, "Failed to resume device: %d\n", ret);
 382
 383         disable_irq(rmi_i2c->irq);
 384
 385         regulator_bulk_disable(ARRAY_SIZE(rmi_i2c->supplies),
 386                                rmi_i2c->supplies);
 387
 388         return 0;
 389 }
 390
 391 static int rmi_i2c_runtime_resume(struct device *dev)
 392 {
 393         struct i2c_client *client = to_i2c_client(dev);
 394         struct rmi_i2c_xport *rmi_i2c = i2c_get_clientdata(client);
 395         int ret;
 396
 397         ret = regulator_bulk_enable(ARRAY_SIZE(rmi_i2c->supplies),
 398                                     rmi_i2c->supplies);
 399         if (ret)
 400                 return ret;
 401
 402         msleep(rmi_i2c->startup_delay);
 403
 404         enable_irq(rmi_i2c->irq);
 405
 406         ret = rmi_driver_resume(rmi_i2c->xport.rmi_dev);
 407         if (ret)
 408                 dev_warn(dev, "Failed to resume device: %d\n", ret);
 409
 410         return 0;
 411 }
 412 #endif
 413
 414 static const struct dev_pm_ops rmi_i2c_pm = {
 415         SET_SYSTEM_SLEEP_PM_OPS(rmi_i2c_suspend, rmi_i2c_resume)
 416         SET_RUNTIME_PM_OPS(rmi_i2c_runtime_suspend, rmi_i2c_runtime_resume,
 417                            NULL)
 418 };
 419
 420 static const struct i2c_device_id rmi_id[] = {
 421         { "rmi4_i2c", 0 },
 422         { }
 423 };
 424 MODULE_DEVICE_TABLE(i2c, rmi_id);
 425
 426 static struct i2c_driver rmi_i2c_driver = {
 427         .driver = {
 428                 .name   = "rmi4_i2c",
 429                 .pm     = &rmi_i2c_pm,
 430                 .of_match_table = of_match_ptr(rmi_i2c_of_match),
 431         },
 432         .id_table       = rmi_id,
 433         .probe          = rmi_i2c_probe,
 434         .remove         = rmi_i2c_remove,
 435 };
 436
 437 module_i2c_driver(rmi_i2c_driver);
 438
 439 MODULE_AUTHOR("Christopher Heiny <cheiny@synaptics.com>");
 440 MODULE_AUTHOR("Andrew Duggan <aduggan@synaptics.com>");
 441 MODULE_DESCRIPTION("RMI I2C driver");
 442 MODULE_LICENSE("GPL");
 443 MODULE_VERSION(RMI_DRIVER_VERSION);