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