Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input
[muen/linux.git] / 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/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");