1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Copyright (c) 2015 - 2016 Red Hat, Inc
4 * Copyright (c) 2011, 2012 Synaptics Incorporated
5 * Copyright (c) 2011 Unixphere
6 */
7
8 #include <linux/kernel.h>
9 #include <linux/delay.h>
10 #include <linux/i2c.h>
11 #include <linux/interrupt.h>
12 #include <linux/kconfig.h>
13 #include <linux/lockdep.h>
14 #include <linux/module.h>
15 #include <linux/pm.h>
16 #include <linux/rmi.h>
17 #include <linux/slab.h>
18 #include "rmi_driver.h"
19
20 #define SMB_PROTOCOL_VERSION_ADDRESS 0xfd
21 #define SMB_MAX_COUNT 32
22 #define RMI_SMB2_MAP_SIZE 8 /* 8 entry of 4 bytes each */
23 #define RMI_SMB2_MAP_FLAGS_WE 0x01
24
25 struct mapping_table_entry {
26 __le16 rmiaddr;
27 u8 readcount;
28 u8 flags;
29 };
30
31 struct rmi_smb_xport {
32 struct rmi_transport_dev xport;
33 struct i2c_client *client;
34
35 struct mutex page_mutex;
36 int page;
37 u8 table_index;
38 struct mutex mappingtable_mutex;
39 struct mapping_table_entry mapping_table[RMI_SMB2_MAP_SIZE];
40 };
41
rmi_smb_get_version(struct rmi_smb_xport * rmi_smb)42 static int rmi_smb_get_version(struct rmi_smb_xport *rmi_smb)
43 {
44 struct i2c_client *client = rmi_smb->client;
45 int retval;
46
47 /* Check if for SMBus new version device by reading version byte. */
48 retval = i2c_smbus_read_byte_data(client, SMB_PROTOCOL_VERSION_ADDRESS);
49 if (retval < 0) {
50 dev_err(&client->dev, "failed to get SMBus version number!\n");
51 return retval;
52 }
53
54 return retval + 1;
55 }
56
57 /* SMB block write - wrapper over ic2_smb_write_block */
smb_block_write(struct rmi_transport_dev * xport,u8 commandcode,const void * buf,size_t len)58 static int smb_block_write(struct rmi_transport_dev *xport,
59 u8 commandcode, const void *buf, size_t len)
60 {
61 struct rmi_smb_xport *rmi_smb =
62 container_of(xport, struct rmi_smb_xport, xport);
63 struct i2c_client *client = rmi_smb->client;
64 int retval;
65
66 retval = i2c_smbus_write_block_data(client, commandcode, len, buf);
67
68 rmi_dbg(RMI_DEBUG_XPORT, &client->dev,
69 "wrote %zd bytes at %#04x: %d (%*ph)\n",
70 len, commandcode, retval, (int)len, buf);
71
72 return retval;
73 }
74
75 /*
76 * The function to get command code for smbus operations and keeps
77 * records to the driver mapping table
78 */
rmi_smb_get_command_code(struct rmi_transport_dev * xport,u16 rmiaddr,int bytecount,bool isread,u8 * commandcode)79 static int rmi_smb_get_command_code(struct rmi_transport_dev *xport,
80 u16 rmiaddr, int bytecount, bool isread, u8 *commandcode)
81 {
82 struct rmi_smb_xport *rmi_smb =
83 container_of(xport, struct rmi_smb_xport, xport);
84 struct mapping_table_entry new_map;
85 int i;
86 int retval = 0;
87
88 mutex_lock(&rmi_smb->mappingtable_mutex);
89
90 for (i = 0; i < RMI_SMB2_MAP_SIZE; i++) {
91 struct mapping_table_entry *entry = &rmi_smb->mapping_table[i];
92
93 if (le16_to_cpu(entry->rmiaddr) == rmiaddr) {
94 if (isread) {
95 if (entry->readcount == bytecount)
96 goto exit;
97 } else {
98 if (entry->flags & RMI_SMB2_MAP_FLAGS_WE) {
99 goto exit;
100 }
101 }
102 }
103 }
104
105 i = rmi_smb->table_index;
106 rmi_smb->table_index = (i + 1) % RMI_SMB2_MAP_SIZE;
107
108 /* constructs mapping table data entry. 4 bytes each entry */
109 memset(&new_map, 0, sizeof(new_map));
110 new_map.rmiaddr = cpu_to_le16(rmiaddr);
111 new_map.readcount = bytecount;
112 new_map.flags = !isread ? RMI_SMB2_MAP_FLAGS_WE : 0;
113
114 retval = smb_block_write(xport, i + 0x80, &new_map, sizeof(new_map));
115 if (retval < 0) {
116 /*
117 * if not written to device mapping table
118 * clear the driver mapping table records
119 */
120 memset(&new_map, 0, sizeof(new_map));
121 }
122
123 /* save to the driver level mapping table */
124 rmi_smb->mapping_table[i] = new_map;
125
126 exit:
127 mutex_unlock(&rmi_smb->mappingtable_mutex);
128
129 if (retval < 0)
130 return retval;
131
132 *commandcode = i;
133 return 0;
134 }
135
rmi_smb_write_block(struct rmi_transport_dev * xport,u16 rmiaddr,const void * databuff,size_t len)136 static int rmi_smb_write_block(struct rmi_transport_dev *xport, u16 rmiaddr,
137 const void *databuff, size_t len)
138 {
139 int retval = 0;
140 u8 commandcode;
141 struct rmi_smb_xport *rmi_smb =
142 container_of(xport, struct rmi_smb_xport, xport);
143 int cur_len = (int)len;
144
145 mutex_lock(&rmi_smb->page_mutex);
146
147 while (cur_len > 0) {
148 /*
149 * break into 32 bytes chunks to write get command code
150 */
151 int block_len = min_t(int, len, SMB_MAX_COUNT);
152
153 retval = rmi_smb_get_command_code(xport, rmiaddr, block_len,
154 false, &commandcode);
155 if (retval < 0)
156 goto exit;
157
158 retval = smb_block_write(xport, commandcode,
159 databuff, block_len);
160 if (retval < 0)
161 goto exit;
162
163 /* prepare to write next block of bytes */
164 cur_len -= SMB_MAX_COUNT;
165 databuff += SMB_MAX_COUNT;
166 rmiaddr += SMB_MAX_COUNT;
167 }
168 exit:
169 mutex_unlock(&rmi_smb->page_mutex);
170 return retval;
171 }
172
173 /* SMB block read - wrapper over ic2_smb_read_block */
smb_block_read(struct rmi_transport_dev * xport,u8 commandcode,void * buf,size_t len)174 static int smb_block_read(struct rmi_transport_dev *xport,
175 u8 commandcode, void *buf, size_t len)
176 {
177 struct rmi_smb_xport *rmi_smb =
178 container_of(xport, struct rmi_smb_xport, xport);
179 struct i2c_client *client = rmi_smb->client;
180
181 return i2c_smbus_read_block_data(client, commandcode, buf);
182 }
183
rmi_smb_read_block(struct rmi_transport_dev * xport,u16 rmiaddr,void * databuff,size_t len)184 static int rmi_smb_read_block(struct rmi_transport_dev *xport, u16 rmiaddr,
185 void *databuff, size_t len)
186 {
187 struct rmi_smb_xport *rmi_smb =
188 container_of(xport, struct rmi_smb_xport, xport);
189 int retval;
190 u8 commandcode;
191 int cur_len = (int)len;
192
193 mutex_lock(&rmi_smb->page_mutex);
194 memset(databuff, 0, len);
195
196 while (cur_len > 0) {
197 /* break into 32 bytes chunks to write get command code */
198 int block_len = min_t(int, cur_len, SMB_MAX_COUNT);
199
200 retval = rmi_smb_get_command_code(xport, rmiaddr, block_len,
201 true, &commandcode);
202 if (retval < 0)
203 goto exit;
204
205 retval = smb_block_read(xport, commandcode,
206 databuff, block_len);
207 if (retval < 0)
208 goto exit;
209
210 /* prepare to read next block of bytes */
211 cur_len -= SMB_MAX_COUNT;
212 databuff += SMB_MAX_COUNT;
213 rmiaddr += SMB_MAX_COUNT;
214 }
215
216 retval = 0;
217
218 exit:
219 mutex_unlock(&rmi_smb->page_mutex);
220 return retval;
221 }
222
rmi_smb_clear_state(struct rmi_smb_xport * rmi_smb)223 static void rmi_smb_clear_state(struct rmi_smb_xport *rmi_smb)
224 {
225 /* the mapping table has been flushed, discard the current one */
226 mutex_lock(&rmi_smb->mappingtable_mutex);
227 memset(rmi_smb->mapping_table, 0, sizeof(rmi_smb->mapping_table));
228 mutex_unlock(&rmi_smb->mappingtable_mutex);
229 }
230
rmi_smb_enable_smbus_mode(struct rmi_smb_xport * rmi_smb)231 static int rmi_smb_enable_smbus_mode(struct rmi_smb_xport *rmi_smb)
232 {
233 struct i2c_client *client = rmi_smb->client;
234 int smbus_version;
235
236 /*
237 * psmouse driver resets the controller, we only need to wait
238 * to give the firmware chance to fully reinitialize.
239 */
240 if (rmi_smb->xport.pdata.reset_delay_ms)
241 msleep(rmi_smb->xport.pdata.reset_delay_ms);
242
243 /* we need to get the smbus version to activate the touchpad */
244 smbus_version = rmi_smb_get_version(rmi_smb);
245 if (smbus_version < 0)
246 return smbus_version;
247
248 rmi_dbg(RMI_DEBUG_XPORT, &client->dev, "Smbus version is %d",
249 smbus_version);
250
251 if (smbus_version != 2 && smbus_version != 3) {
252 dev_err(&client->dev, "Unrecognized SMB version %d\n",
253 smbus_version);
254 return -ENODEV;
255 }
256
257 return 0;
258 }
259
rmi_smb_reset(struct rmi_transport_dev * xport,u16 reset_addr)260 static int rmi_smb_reset(struct rmi_transport_dev *xport, u16 reset_addr)
261 {
262 struct rmi_smb_xport *rmi_smb =
263 container_of(xport, struct rmi_smb_xport, xport);
264
265 rmi_smb_clear_state(rmi_smb);
266
267 /*
268 * We do not call the actual reset command, it has to be handled in
269 * PS/2 or there will be races between PS/2 and SMBus. PS/2 should
270 * ensure that a psmouse_reset is called before initializing the
271 * device and after it has been removed to be in a known state.
272 */
273 return rmi_smb_enable_smbus_mode(rmi_smb);
274 }
275
276 static const struct rmi_transport_ops rmi_smb_ops = {
277 .write_block = rmi_smb_write_block,
278 .read_block = rmi_smb_read_block,
279 .reset = rmi_smb_reset,
280 };
281
rmi_smb_probe(struct i2c_client * client)282 static int rmi_smb_probe(struct i2c_client *client)
283 {
284 struct rmi_device_platform_data *pdata = dev_get_platdata(&client->dev);
285 struct rmi_smb_xport *rmi_smb;
286 int error;
287
288 if (!pdata) {
289 dev_err(&client->dev, "no platform data, aborting\n");
290 return -ENOMEM;
291 }
292
293 if (!i2c_check_functionality(client->adapter,
294 I2C_FUNC_SMBUS_READ_BLOCK_DATA |
295 I2C_FUNC_SMBUS_HOST_NOTIFY)) {
296 dev_err(&client->dev,
297 "adapter does not support required functionality\n");
298 return -ENODEV;
299 }
300
301 if (client->irq <= 0) {
302 dev_err(&client->dev, "no IRQ provided, giving up\n");
303 return client->irq ? client->irq : -ENODEV;
304 }
305
306 rmi_smb = devm_kzalloc(&client->dev, sizeof(struct rmi_smb_xport),
307 GFP_KERNEL);
308 if (!rmi_smb)
309 return -ENOMEM;
310
311 rmi_dbg(RMI_DEBUG_XPORT, &client->dev, "Probing %s\n",
312 dev_name(&client->dev));
313
314 rmi_smb->client = client;
315 mutex_init(&rmi_smb->page_mutex);
316 mutex_init(&rmi_smb->mappingtable_mutex);
317
318 rmi_smb->xport.dev = &client->dev;
319 rmi_smb->xport.pdata = *pdata;
320 rmi_smb->xport.pdata.irq = client->irq;
321 rmi_smb->xport.proto_name = "smb";
322 rmi_smb->xport.ops = &rmi_smb_ops;
323
324 error = rmi_smb_enable_smbus_mode(rmi_smb);
325 if (error)
326 return error;
327
328 i2c_set_clientdata(client, rmi_smb);
329
330 dev_info(&client->dev, "registering SMbus-connected sensor\n");
331
332 error = rmi_register_transport_device(&rmi_smb->xport);
333 if (error) {
334 dev_err(&client->dev, "failed to register sensor: %d\n", error);
335 return error;
336 }
337
338 return 0;
339 }
340
rmi_smb_remove(struct i2c_client * client)341 static void rmi_smb_remove(struct i2c_client *client)
342 {
343 struct rmi_smb_xport *rmi_smb = i2c_get_clientdata(client);
344
345 rmi_unregister_transport_device(&rmi_smb->xport);
346 }
347
rmi_smb_suspend(struct device * dev)348 static int rmi_smb_suspend(struct device *dev)
349 {
350 struct i2c_client *client = to_i2c_client(dev);
351 struct rmi_smb_xport *rmi_smb = i2c_get_clientdata(client);
352 int ret;
353
354 ret = rmi_driver_suspend(rmi_smb->xport.rmi_dev, true);
355 if (ret)
356 dev_warn(dev, "Failed to suspend device: %d\n", ret);
357
358 return ret;
359 }
360
rmi_smb_runtime_suspend(struct device * dev)361 static int rmi_smb_runtime_suspend(struct device *dev)
362 {
363 struct i2c_client *client = to_i2c_client(dev);
364 struct rmi_smb_xport *rmi_smb = i2c_get_clientdata(client);
365 int ret;
366
367 ret = rmi_driver_suspend(rmi_smb->xport.rmi_dev, false);
368 if (ret)
369 dev_warn(dev, "Failed to suspend device: %d\n", ret);
370
371 return ret;
372 }
373
rmi_smb_resume(struct device * dev)374 static int rmi_smb_resume(struct device *dev)
375 {
376 struct i2c_client *client = container_of(dev, struct i2c_client, dev);
377 struct rmi_smb_xport *rmi_smb = i2c_get_clientdata(client);
378 struct rmi_device *rmi_dev = rmi_smb->xport.rmi_dev;
379 int ret;
380
381 rmi_smb_reset(&rmi_smb->xport, 0);
382
383 rmi_reset(rmi_dev);
384
385 ret = rmi_driver_resume(rmi_smb->xport.rmi_dev, true);
386 if (ret)
387 dev_warn(dev, "Failed to resume device: %d\n", ret);
388
389 return 0;
390 }
391
rmi_smb_runtime_resume(struct device * dev)392 static int rmi_smb_runtime_resume(struct device *dev)
393 {
394 struct i2c_client *client = to_i2c_client(dev);
395 struct rmi_smb_xport *rmi_smb = i2c_get_clientdata(client);
396 int ret;
397
398 ret = rmi_driver_resume(rmi_smb->xport.rmi_dev, false);
399 if (ret)
400 dev_warn(dev, "Failed to resume device: %d\n", ret);
401
402 return 0;
403 }
404
405 static const struct dev_pm_ops rmi_smb_pm = {
406 SYSTEM_SLEEP_PM_OPS(rmi_smb_suspend, rmi_smb_resume)
407 RUNTIME_PM_OPS(rmi_smb_runtime_suspend, rmi_smb_runtime_resume, NULL)
408 };
409
410 static const struct i2c_device_id rmi_id[] = {
411 { .name = "rmi4_smbus" },
412 { }
413 };
414 MODULE_DEVICE_TABLE(i2c, rmi_id);
415
416 static struct i2c_driver rmi_smb_driver = {
417 .driver = {
418 .name = "rmi4_smbus",
419 .pm = pm_ptr(&rmi_smb_pm),
420 },
421 .id_table = rmi_id,
422 .probe = rmi_smb_probe,
423 .remove = rmi_smb_remove,
424 };
425
426 module_i2c_driver(rmi_smb_driver);
427
428 MODULE_AUTHOR("Andrew Duggan <aduggan@synaptics.com>");
429 MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@redhat.com>");
430 MODULE_DESCRIPTION("RMI4 SMBus driver");
431 MODULE_LICENSE("GPL");
432