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); 444