GNU Linux-libre 4.14.266-gnu1
[releases.git] / drivers / input / 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         int retval;
242
243         /* we need to get the smbus version to activate the touchpad */
244         retval = rmi_smb_get_version(rmi_smb);
245         if (retval < 0)
246                 return retval;
247
248         return 0;
249 }
250
251 static int rmi_smb_reset(struct rmi_transport_dev *xport, u16 reset_addr)
252 {
253         struct rmi_smb_xport *rmi_smb =
254                 container_of(xport, struct rmi_smb_xport, xport);
255
256         rmi_smb_clear_state(rmi_smb);
257
258         /*
259          * we do not call the actual reset command, it has to be handled in
260          * PS/2 or there will be races between PS/2 and SMBus.
261          * PS/2 should ensure that a psmouse_reset is called before
262          * intializing the device and after it has been removed to be in a known
263          * state.
264          */
265         return rmi_smb_enable_smbus_mode(rmi_smb);
266 }
267
268 static const struct rmi_transport_ops rmi_smb_ops = {
269         .write_block    = rmi_smb_write_block,
270         .read_block     = rmi_smb_read_block,
271         .reset          = rmi_smb_reset,
272 };
273
274 static int rmi_smb_probe(struct i2c_client *client,
275                          const struct i2c_device_id *id)
276 {
277         struct rmi_device_platform_data *pdata = dev_get_platdata(&client->dev);
278         struct rmi_smb_xport *rmi_smb;
279         int smbus_version;
280         int error;
281
282         if (!pdata) {
283                 dev_err(&client->dev, "no platform data, aborting\n");
284                 return -ENOMEM;
285         }
286
287         if (!i2c_check_functionality(client->adapter,
288                                      I2C_FUNC_SMBUS_READ_BLOCK_DATA |
289                                      I2C_FUNC_SMBUS_HOST_NOTIFY)) {
290                 dev_err(&client->dev,
291                         "adapter does not support required functionality\n");
292                 return -ENODEV;
293         }
294
295         if (client->irq <= 0) {
296                 dev_err(&client->dev, "no IRQ provided, giving up\n");
297                 return client->irq ? client->irq : -ENODEV;
298         }
299
300         rmi_smb = devm_kzalloc(&client->dev, sizeof(struct rmi_smb_xport),
301                                 GFP_KERNEL);
302         if (!rmi_smb)
303                 return -ENOMEM;
304
305         rmi_dbg(RMI_DEBUG_XPORT, &client->dev, "Probing %s\n",
306                 dev_name(&client->dev));
307
308         rmi_smb->client = client;
309         mutex_init(&rmi_smb->page_mutex);
310         mutex_init(&rmi_smb->mappingtable_mutex);
311
312         rmi_smb->xport.dev = &client->dev;
313         rmi_smb->xport.pdata = *pdata;
314         rmi_smb->xport.pdata.irq = client->irq;
315         rmi_smb->xport.proto_name = "smb";
316         rmi_smb->xport.ops = &rmi_smb_ops;
317
318         smbus_version = rmi_smb_get_version(rmi_smb);
319         if (smbus_version < 0)
320                 return smbus_version;
321
322         rmi_dbg(RMI_DEBUG_XPORT, &client->dev, "Smbus version is %d",
323                 smbus_version);
324
325         if (smbus_version != 2 && smbus_version != 3) {
326                 dev_err(&client->dev, "Unrecognized SMB version %d\n",
327                                 smbus_version);
328                 return -ENODEV;
329         }
330
331         i2c_set_clientdata(client, rmi_smb);
332
333         dev_info(&client->dev, "registering SMbus-connected sensor\n");
334
335         error = rmi_register_transport_device(&rmi_smb->xport);
336         if (error) {
337                 dev_err(&client->dev, "failed to register sensor: %d\n", error);
338                 return error;
339         }
340
341         return 0;
342 }
343
344 static int rmi_smb_remove(struct i2c_client *client)
345 {
346         struct rmi_smb_xport *rmi_smb = i2c_get_clientdata(client);
347
348         rmi_unregister_transport_device(&rmi_smb->xport);
349
350         return 0;
351 }
352
353 static int __maybe_unused rmi_smb_suspend(struct device *dev)
354 {
355         struct i2c_client *client = to_i2c_client(dev);
356         struct rmi_smb_xport *rmi_smb = i2c_get_clientdata(client);
357         int ret;
358
359         ret = rmi_driver_suspend(rmi_smb->xport.rmi_dev, true);
360         if (ret)
361                 dev_warn(dev, "Failed to suspend device: %d\n", ret);
362
363         return ret;
364 }
365
366 static int __maybe_unused rmi_smb_runtime_suspend(struct device *dev)
367 {
368         struct i2c_client *client = to_i2c_client(dev);
369         struct rmi_smb_xport *rmi_smb = i2c_get_clientdata(client);
370         int ret;
371
372         ret = rmi_driver_suspend(rmi_smb->xport.rmi_dev, false);
373         if (ret)
374                 dev_warn(dev, "Failed to suspend device: %d\n", ret);
375
376         return ret;
377 }
378
379 static int __maybe_unused rmi_smb_resume(struct device *dev)
380 {
381         struct i2c_client *client = container_of(dev, struct i2c_client, dev);
382         struct rmi_smb_xport *rmi_smb = i2c_get_clientdata(client);
383         struct rmi_device *rmi_dev = rmi_smb->xport.rmi_dev;
384         int ret;
385
386         rmi_smb_reset(&rmi_smb->xport, 0);
387
388         rmi_reset(rmi_dev);
389
390         ret = rmi_driver_resume(rmi_smb->xport.rmi_dev, true);
391         if (ret)
392                 dev_warn(dev, "Failed to resume device: %d\n", ret);
393
394         return 0;
395 }
396
397 static int __maybe_unused rmi_smb_runtime_resume(struct device *dev)
398 {
399         struct i2c_client *client = to_i2c_client(dev);
400         struct rmi_smb_xport *rmi_smb = i2c_get_clientdata(client);
401         int ret;
402
403         ret = rmi_driver_resume(rmi_smb->xport.rmi_dev, false);
404         if (ret)
405                 dev_warn(dev, "Failed to resume device: %d\n", ret);
406
407         return 0;
408 }
409
410 static const struct dev_pm_ops rmi_smb_pm = {
411         SET_SYSTEM_SLEEP_PM_OPS(rmi_smb_suspend, rmi_smb_resume)
412         SET_RUNTIME_PM_OPS(rmi_smb_runtime_suspend, rmi_smb_runtime_resume,
413                            NULL)
414 };
415
416 static const struct i2c_device_id rmi_id[] = {
417         { "rmi4_smbus", 0 },
418         { }
419 };
420 MODULE_DEVICE_TABLE(i2c, rmi_id);
421
422 static struct i2c_driver rmi_smb_driver = {
423         .driver = {
424                 .name   = "rmi4_smbus",
425                 .pm     = &rmi_smb_pm,
426         },
427         .id_table       = rmi_id,
428         .probe          = rmi_smb_probe,
429         .remove         = rmi_smb_remove,
430 };
431
432 module_i2c_driver(rmi_smb_driver);
433
434 MODULE_AUTHOR("Andrew Duggan <aduggan@synaptics.com>");
435 MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@redhat.com>");
436 MODULE_DESCRIPTION("RMI4 SMBus driver");
437 MODULE_LICENSE("GPL");