2 * Copyright (c) 2015 - 2016 Red Hat, Inc
3 * Copyright (c) 2011, 2012 Synaptics Incorporated
4 * Copyright (c) 2011 Unixphere
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.
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>
19 #include <linux/rmi.h>
20 #include <linux/slab.h>
21 #include "rmi_driver.h"
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
28 struct mapping_table_entry
{
34 struct rmi_smb_xport
{
35 struct rmi_transport_dev xport
;
36 struct i2c_client
*client
;
38 struct mutex page_mutex
;
41 struct mutex mappingtable_mutex
;
42 struct mapping_table_entry mapping_table
[RMI_SMB2_MAP_SIZE
];
45 static int rmi_smb_get_version(struct rmi_smb_xport
*rmi_smb
)
47 struct i2c_client
*client
= rmi_smb
->client
;
50 /* Check if for SMBus new version device by reading version byte. */
51 retval
= i2c_smbus_read_byte_data(client
, SMB_PROTOCOL_VERSION_ADDRESS
);
53 dev_err(&client
->dev
, "failed to get SMBus version number!\n");
59 /* SMB block write - wrapper over ic2_smb_write_block */
60 static int smb_block_write(struct rmi_transport_dev
*xport
,
61 u8 commandcode
, const void *buf
, size_t len
)
63 struct rmi_smb_xport
*rmi_smb
=
64 container_of(xport
, struct rmi_smb_xport
, xport
);
65 struct i2c_client
*client
= rmi_smb
->client
;
68 retval
= i2c_smbus_write_block_data(client
, commandcode
, len
, buf
);
70 rmi_dbg(RMI_DEBUG_XPORT
, &client
->dev
,
71 "wrote %zd bytes at %#04x: %d (%*ph)\n",
72 len
, commandcode
, retval
, (int)len
, buf
);
78 * The function to get command code for smbus operations and keeps
79 * records to the driver mapping table
81 static int rmi_smb_get_command_code(struct rmi_transport_dev
*xport
,
82 u16 rmiaddr
, int bytecount
, bool isread
, u8
*commandcode
)
84 struct rmi_smb_xport
*rmi_smb
=
85 container_of(xport
, struct rmi_smb_xport
, xport
);
88 struct mapping_table_entry mapping_data
[1];
90 mutex_lock(&rmi_smb
->mappingtable_mutex
);
91 for (i
= 0; i
< RMI_SMB2_MAP_SIZE
; i
++) {
92 struct mapping_table_entry
*entry
= &rmi_smb
->mapping_table
[i
];
94 if (le16_to_cpu(entry
->rmiaddr
) == rmiaddr
) {
96 if (entry
->readcount
== bytecount
) {
102 if (entry
->flags
& RMI_SMB2_MAP_FLAGS_WE
) {
110 i
= rmi_smb
->table_index
;
111 rmi_smb
->table_index
= (i
+ 1) % RMI_SMB2_MAP_SIZE
;
113 /* constructs mapping table data entry. 4 bytes each entry */
114 memset(mapping_data
, 0, sizeof(mapping_data
));
116 mapping_data
[0].rmiaddr
= cpu_to_le16(rmiaddr
);
117 mapping_data
[0].readcount
= bytecount
;
118 mapping_data
[0].flags
= !isread
? RMI_SMB2_MAP_FLAGS_WE
: 0;
120 retval
= smb_block_write(xport
, i
+ 0x80, mapping_data
,
121 sizeof(mapping_data
));
125 * if not written to device mapping table
126 * clear the driver mapping table records
128 rmi_smb
->mapping_table
[i
].rmiaddr
= 0x0000;
129 rmi_smb
->mapping_table
[i
].readcount
= 0;
130 rmi_smb
->mapping_table
[i
].flags
= 0;
133 /* save to the driver level mapping table */
134 rmi_smb
->mapping_table
[i
].rmiaddr
= rmiaddr
;
135 rmi_smb
->mapping_table
[i
].readcount
= bytecount
;
136 rmi_smb
->mapping_table
[i
].flags
= !isread
? RMI_SMB2_MAP_FLAGS_WE
: 0;
140 mutex_unlock(&rmi_smb
->mappingtable_mutex
);
145 static int rmi_smb_write_block(struct rmi_transport_dev
*xport
, u16 rmiaddr
,
146 const void *databuff
, size_t len
)
150 struct rmi_smb_xport
*rmi_smb
=
151 container_of(xport
, struct rmi_smb_xport
, xport
);
152 int cur_len
= (int)len
;
154 mutex_lock(&rmi_smb
->page_mutex
);
156 while (cur_len
> 0) {
158 * break into 32 bytes chunks to write get command code
160 int block_len
= min_t(int, len
, SMB_MAX_COUNT
);
162 retval
= rmi_smb_get_command_code(xport
, rmiaddr
, block_len
,
163 false, &commandcode
);
167 retval
= smb_block_write(xport
, commandcode
,
168 databuff
, block_len
);
172 /* prepare to write next block of bytes */
173 cur_len
-= SMB_MAX_COUNT
;
174 databuff
+= SMB_MAX_COUNT
;
175 rmiaddr
+= SMB_MAX_COUNT
;
178 mutex_unlock(&rmi_smb
->page_mutex
);
182 /* SMB block read - wrapper over ic2_smb_read_block */
183 static int smb_block_read(struct rmi_transport_dev
*xport
,
184 u8 commandcode
, void *buf
, size_t len
)
186 struct rmi_smb_xport
*rmi_smb
=
187 container_of(xport
, struct rmi_smb_xport
, xport
);
188 struct i2c_client
*client
= rmi_smb
->client
;
191 retval
= i2c_smbus_read_block_data(client
, commandcode
, buf
);
198 static int rmi_smb_read_block(struct rmi_transport_dev
*xport
, u16 rmiaddr
,
199 void *databuff
, size_t len
)
201 struct rmi_smb_xport
*rmi_smb
=
202 container_of(xport
, struct rmi_smb_xport
, xport
);
205 int cur_len
= (int)len
;
207 mutex_lock(&rmi_smb
->page_mutex
);
208 memset(databuff
, 0, len
);
210 while (cur_len
> 0) {
211 /* break into 32 bytes chunks to write get command code */
212 int block_len
= min_t(int, cur_len
, SMB_MAX_COUNT
);
214 retval
= rmi_smb_get_command_code(xport
, rmiaddr
, block_len
,
219 retval
= smb_block_read(xport
, commandcode
,
220 databuff
, block_len
);
224 /* prepare to read next block of bytes */
225 cur_len
-= SMB_MAX_COUNT
;
226 databuff
+= SMB_MAX_COUNT
;
227 rmiaddr
+= SMB_MAX_COUNT
;
233 mutex_unlock(&rmi_smb
->page_mutex
);
237 static void rmi_smb_clear_state(struct rmi_smb_xport
*rmi_smb
)
239 /* the mapping table has been flushed, discard the current one */
240 mutex_lock(&rmi_smb
->mappingtable_mutex
);
241 memset(rmi_smb
->mapping_table
, 0, sizeof(rmi_smb
->mapping_table
));
242 mutex_unlock(&rmi_smb
->mappingtable_mutex
);
245 static int rmi_smb_enable_smbus_mode(struct rmi_smb_xport
*rmi_smb
)
249 /* we need to get the smbus version to activate the touchpad */
250 retval
= rmi_smb_get_version(rmi_smb
);
257 static int rmi_smb_reset(struct rmi_transport_dev
*xport
, u16 reset_addr
)
259 struct rmi_smb_xport
*rmi_smb
=
260 container_of(xport
, struct rmi_smb_xport
, xport
);
262 rmi_smb_clear_state(rmi_smb
);
265 * we do not call the actual reset command, it has to be handled in
266 * PS/2 or there will be races between PS/2 and SMBus.
267 * PS/2 should ensure that a psmouse_reset is called before
268 * intializing the device and after it has been removed to be in a known
271 return rmi_smb_enable_smbus_mode(rmi_smb
);
274 static const struct rmi_transport_ops rmi_smb_ops
= {
275 .write_block
= rmi_smb_write_block
,
276 .read_block
= rmi_smb_read_block
,
277 .reset
= rmi_smb_reset
,
280 static int rmi_smb_probe(struct i2c_client
*client
,
281 const struct i2c_device_id
*id
)
283 struct rmi_device_platform_data
*pdata
= dev_get_platdata(&client
->dev
);
284 struct rmi_smb_xport
*rmi_smb
;
288 if (!i2c_check_functionality(client
->adapter
,
289 I2C_FUNC_SMBUS_READ_BLOCK_DATA
|
290 I2C_FUNC_SMBUS_HOST_NOTIFY
)) {
291 dev_err(&client
->dev
,
292 "adapter does not support required functionality.\n");
296 if (client
->irq
<= 0) {
297 dev_err(&client
->dev
, "no IRQ provided, giving up.\n");
298 return client
->irq
? client
->irq
: -ENODEV
;
301 rmi_smb
= devm_kzalloc(&client
->dev
, sizeof(struct rmi_smb_xport
),
307 dev_err(&client
->dev
, "no platform data, aborting\n");
311 rmi_dbg(RMI_DEBUG_XPORT
, &client
->dev
, "Probing %s.\n",
312 dev_name(&client
->dev
));
314 rmi_smb
->client
= client
;
315 mutex_init(&rmi_smb
->page_mutex
);
316 mutex_init(&rmi_smb
->mappingtable_mutex
);
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
= "smb2";
322 rmi_smb
->xport
.ops
= &rmi_smb_ops
;
324 retval
= rmi_smb_get_version(rmi_smb
);
328 smbus_version
= retval
;
329 rmi_dbg(RMI_DEBUG_XPORT
, &client
->dev
, "Smbus version is %d",
332 if (smbus_version
!= 2) {
333 dev_err(&client
->dev
, "Unrecognized SMB version %d.\n",
338 i2c_set_clientdata(client
, rmi_smb
);
340 retval
= rmi_register_transport_device(&rmi_smb
->xport
);
342 dev_err(&client
->dev
, "Failed to register transport driver at 0x%.2X.\n",
344 i2c_set_clientdata(client
, NULL
);
348 dev_info(&client
->dev
, "registered rmi smb driver at %#04x.\n",
354 static int rmi_smb_remove(struct i2c_client
*client
)
356 struct rmi_smb_xport
*rmi_smb
= i2c_get_clientdata(client
);
358 rmi_unregister_transport_device(&rmi_smb
->xport
);
363 static int __maybe_unused
rmi_smb_suspend(struct device
*dev
)
365 struct i2c_client
*client
= to_i2c_client(dev
);
366 struct rmi_smb_xport
*rmi_smb
= i2c_get_clientdata(client
);
369 ret
= rmi_driver_suspend(rmi_smb
->xport
.rmi_dev
, true);
371 dev_warn(dev
, "Failed to suspend device: %d\n", ret
);
376 static int __maybe_unused
rmi_smb_runtime_suspend(struct device
*dev
)
378 struct i2c_client
*client
= to_i2c_client(dev
);
379 struct rmi_smb_xport
*rmi_smb
= i2c_get_clientdata(client
);
382 ret
= rmi_driver_suspend(rmi_smb
->xport
.rmi_dev
, false);
384 dev_warn(dev
, "Failed to suspend device: %d\n", ret
);
389 static int __maybe_unused
rmi_smb_resume(struct device
*dev
)
391 struct i2c_client
*client
= container_of(dev
, struct i2c_client
, dev
);
392 struct rmi_smb_xport
*rmi_smb
= i2c_get_clientdata(client
);
393 struct rmi_device
*rmi_dev
= rmi_smb
->xport
.rmi_dev
;
396 rmi_smb_reset(&rmi_smb
->xport
, 0);
400 ret
= rmi_driver_resume(rmi_smb
->xport
.rmi_dev
, true);
402 dev_warn(dev
, "Failed to resume device: %d\n", ret
);
407 static int __maybe_unused
rmi_smb_runtime_resume(struct device
*dev
)
409 struct i2c_client
*client
= to_i2c_client(dev
);
410 struct rmi_smb_xport
*rmi_smb
= i2c_get_clientdata(client
);
413 ret
= rmi_driver_resume(rmi_smb
->xport
.rmi_dev
, false);
415 dev_warn(dev
, "Failed to resume device: %d\n", ret
);
420 static const struct dev_pm_ops rmi_smb_pm
= {
421 SET_SYSTEM_SLEEP_PM_OPS(rmi_smb_suspend
, rmi_smb_resume
)
422 SET_RUNTIME_PM_OPS(rmi_smb_runtime_suspend
, rmi_smb_runtime_resume
,
426 static const struct i2c_device_id rmi_id
[] = {
430 MODULE_DEVICE_TABLE(i2c
, rmi_id
);
432 static struct i2c_driver rmi_smb_driver
= {
434 .name
= "rmi4_smbus",
438 .probe
= rmi_smb_probe
,
439 .remove
= rmi_smb_remove
,
442 module_i2c_driver(rmi_smb_driver
);
444 MODULE_AUTHOR("Andrew Duggan <aduggan@synaptics.com>");
445 MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@redhat.com>");
446 MODULE_DESCRIPTION("RMI4 SMBus driver");
447 MODULE_LICENSE("GPL");