Loading...
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
25struct mapping_table_entry {
26 __le16 rmiaddr;
27 u8 readcount;
28 u8 flags;
29};
30
31struct 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
42static 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 */
58static 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 */
79static 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
126exit:
127 mutex_unlock(&rmi_smb->mappingtable_mutex);
128
129 if (retval < 0)
130 return retval;
131
132 *commandcode = i;
133 return 0;
134}
135
136static 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 }
168exit:
169 mutex_unlock(&rmi_smb->page_mutex);
170 return retval;
171}
172
173/* SMB block read - wrapper over ic2_smb_read_block */
174static 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 int retval;
181
182 retval = i2c_smbus_read_block_data(client, commandcode, buf);
183 if (retval < 0)
184 return retval;
185
186 return retval;
187}
188
189static int rmi_smb_read_block(struct rmi_transport_dev *xport, u16 rmiaddr,
190 void *databuff, size_t len)
191{
192 struct rmi_smb_xport *rmi_smb =
193 container_of(xport, struct rmi_smb_xport, xport);
194 int retval;
195 u8 commandcode;
196 int cur_len = (int)len;
197
198 mutex_lock(&rmi_smb->page_mutex);
199 memset(databuff, 0, len);
200
201 while (cur_len > 0) {
202 /* break into 32 bytes chunks to write get command code */
203 int block_len = min_t(int, cur_len, SMB_MAX_COUNT);
204
205 retval = rmi_smb_get_command_code(xport, rmiaddr, block_len,
206 true, &commandcode);
207 if (retval < 0)
208 goto exit;
209
210 retval = smb_block_read(xport, commandcode,
211 databuff, block_len);
212 if (retval < 0)
213 goto exit;
214
215 /* prepare to read next block of bytes */
216 cur_len -= SMB_MAX_COUNT;
217 databuff += SMB_MAX_COUNT;
218 rmiaddr += SMB_MAX_COUNT;
219 }
220
221 retval = 0;
222
223exit:
224 mutex_unlock(&rmi_smb->page_mutex);
225 return retval;
226}
227
228static void rmi_smb_clear_state(struct rmi_smb_xport *rmi_smb)
229{
230 /* the mapping table has been flushed, discard the current one */
231 mutex_lock(&rmi_smb->mappingtable_mutex);
232 memset(rmi_smb->mapping_table, 0, sizeof(rmi_smb->mapping_table));
233 mutex_unlock(&rmi_smb->mappingtable_mutex);
234}
235
236static int rmi_smb_enable_smbus_mode(struct rmi_smb_xport *rmi_smb)
237{
238 int retval;
239
240 /* we need to get the smbus version to activate the touchpad */
241 retval = rmi_smb_get_version(rmi_smb);
242 if (retval < 0)
243 return retval;
244
245 return 0;
246}
247
248static int rmi_smb_reset(struct rmi_transport_dev *xport, u16 reset_addr)
249{
250 struct rmi_smb_xport *rmi_smb =
251 container_of(xport, struct rmi_smb_xport, xport);
252
253 rmi_smb_clear_state(rmi_smb);
254
255 /*
256 * we do not call the actual reset command, it has to be handled in
257 * PS/2 or there will be races between PS/2 and SMBus.
258 * PS/2 should ensure that a psmouse_reset is called before
259 * intializing the device and after it has been removed to be in a known
260 * state.
261 */
262 return rmi_smb_enable_smbus_mode(rmi_smb);
263}
264
265static const struct rmi_transport_ops rmi_smb_ops = {
266 .write_block = rmi_smb_write_block,
267 .read_block = rmi_smb_read_block,
268 .reset = rmi_smb_reset,
269};
270
271static int rmi_smb_probe(struct i2c_client *client)
272{
273 struct rmi_device_platform_data *pdata = dev_get_platdata(&client->dev);
274 struct rmi_smb_xport *rmi_smb;
275 int smbus_version;
276 int error;
277
278 if (!pdata) {
279 dev_err(&client->dev, "no platform data, aborting\n");
280 return -ENOMEM;
281 }
282
283 if (!i2c_check_functionality(client->adapter,
284 I2C_FUNC_SMBUS_READ_BLOCK_DATA |
285 I2C_FUNC_SMBUS_HOST_NOTIFY)) {
286 dev_err(&client->dev,
287 "adapter does not support required functionality\n");
288 return -ENODEV;
289 }
290
291 if (client->irq <= 0) {
292 dev_err(&client->dev, "no IRQ provided, giving up\n");
293 return client->irq ? client->irq : -ENODEV;
294 }
295
296 rmi_smb = devm_kzalloc(&client->dev, sizeof(struct rmi_smb_xport),
297 GFP_KERNEL);
298 if (!rmi_smb)
299 return -ENOMEM;
300
301 rmi_dbg(RMI_DEBUG_XPORT, &client->dev, "Probing %s\n",
302 dev_name(&client->dev));
303
304 rmi_smb->client = client;
305 mutex_init(&rmi_smb->page_mutex);
306 mutex_init(&rmi_smb->mappingtable_mutex);
307
308 rmi_smb->xport.dev = &client->dev;
309 rmi_smb->xport.pdata = *pdata;
310 rmi_smb->xport.pdata.irq = client->irq;
311 rmi_smb->xport.proto_name = "smb";
312 rmi_smb->xport.ops = &rmi_smb_ops;
313
314 smbus_version = rmi_smb_get_version(rmi_smb);
315 if (smbus_version < 0)
316 return smbus_version;
317
318 rmi_dbg(RMI_DEBUG_XPORT, &client->dev, "Smbus version is %d",
319 smbus_version);
320
321 if (smbus_version != 2 && smbus_version != 3) {
322 dev_err(&client->dev, "Unrecognized SMB version %d\n",
323 smbus_version);
324 return -ENODEV;
325 }
326
327 i2c_set_clientdata(client, rmi_smb);
328
329 dev_info(&client->dev, "registering SMbus-connected sensor\n");
330
331 error = rmi_register_transport_device(&rmi_smb->xport);
332 if (error) {
333 dev_err(&client->dev, "failed to register sensor: %d\n", error);
334 return error;
335 }
336
337 return 0;
338}
339
340static void rmi_smb_remove(struct i2c_client *client)
341{
342 struct rmi_smb_xport *rmi_smb = i2c_get_clientdata(client);
343
344 rmi_unregister_transport_device(&rmi_smb->xport);
345}
346
347static int __maybe_unused rmi_smb_suspend(struct device *dev)
348{
349 struct i2c_client *client = to_i2c_client(dev);
350 struct rmi_smb_xport *rmi_smb = i2c_get_clientdata(client);
351 int ret;
352
353 ret = rmi_driver_suspend(rmi_smb->xport.rmi_dev, true);
354 if (ret)
355 dev_warn(dev, "Failed to suspend device: %d\n", ret);
356
357 return ret;
358}
359
360static int __maybe_unused rmi_smb_runtime_suspend(struct device *dev)
361{
362 struct i2c_client *client = to_i2c_client(dev);
363 struct rmi_smb_xport *rmi_smb = i2c_get_clientdata(client);
364 int ret;
365
366 ret = rmi_driver_suspend(rmi_smb->xport.rmi_dev, false);
367 if (ret)
368 dev_warn(dev, "Failed to suspend device: %d\n", ret);
369
370 return ret;
371}
372
373static int __maybe_unused rmi_smb_resume(struct device *dev)
374{
375 struct i2c_client *client = container_of(dev, struct i2c_client, dev);
376 struct rmi_smb_xport *rmi_smb = i2c_get_clientdata(client);
377 struct rmi_device *rmi_dev = rmi_smb->xport.rmi_dev;
378 int ret;
379
380 rmi_smb_reset(&rmi_smb->xport, 0);
381
382 rmi_reset(rmi_dev);
383
384 ret = rmi_driver_resume(rmi_smb->xport.rmi_dev, true);
385 if (ret)
386 dev_warn(dev, "Failed to resume device: %d\n", ret);
387
388 return 0;
389}
390
391static int __maybe_unused rmi_smb_runtime_resume(struct device *dev)
392{
393 struct i2c_client *client = to_i2c_client(dev);
394 struct rmi_smb_xport *rmi_smb = i2c_get_clientdata(client);
395 int ret;
396
397 ret = rmi_driver_resume(rmi_smb->xport.rmi_dev, false);
398 if (ret)
399 dev_warn(dev, "Failed to resume device: %d\n", ret);
400
401 return 0;
402}
403
404static const struct dev_pm_ops rmi_smb_pm = {
405 SET_SYSTEM_SLEEP_PM_OPS(rmi_smb_suspend, rmi_smb_resume)
406 SET_RUNTIME_PM_OPS(rmi_smb_runtime_suspend, rmi_smb_runtime_resume,
407 NULL)
408};
409
410static const struct i2c_device_id rmi_id[] = {
411 { "rmi4_smbus", 0 },
412 { }
413};
414MODULE_DEVICE_TABLE(i2c, rmi_id);
415
416static struct i2c_driver rmi_smb_driver = {
417 .driver = {
418 .name = "rmi4_smbus",
419 .pm = &rmi_smb_pm,
420 },
421 .id_table = rmi_id,
422 .probe_new = rmi_smb_probe,
423 .remove = rmi_smb_remove,
424};
425
426module_i2c_driver(rmi_smb_driver);
427
428MODULE_AUTHOR("Andrew Duggan <aduggan@synaptics.com>");
429MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@redhat.com>");
430MODULE_DESCRIPTION("RMI4 SMBus driver");
431MODULE_LICENSE("GPL");
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
28struct mapping_table_entry {
29 __le16 rmiaddr;
30 u8 readcount;
31 u8 flags;
32};
33
34struct 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
45static 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 */
61static 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 */
82static 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
129exit:
130 mutex_unlock(&rmi_smb->mappingtable_mutex);
131
132 if (retval < 0)
133 return retval;
134
135 *commandcode = i;
136 return 0;
137}
138
139static 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 }
171exit:
172 mutex_unlock(&rmi_smb->page_mutex);
173 return retval;
174}
175
176/* SMB block read - wrapper over ic2_smb_read_block */
177static 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
192static 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
226exit:
227 mutex_unlock(&rmi_smb->page_mutex);
228 return retval;
229}
230
231static 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
239static 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
251static 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
268static 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
274static 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
344static 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
353static 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
366static 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
379static 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
397static 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
410static 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
416static const struct i2c_device_id rmi_id[] = {
417 { "rmi4_smbus", 0 },
418 { }
419};
420MODULE_DEVICE_TABLE(i2c, rmi_id);
421
422static 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
432module_i2c_driver(rmi_smb_driver);
433
434MODULE_AUTHOR("Andrew Duggan <aduggan@synaptics.com>");
435MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@redhat.com>");
436MODULE_DESCRIPTION("RMI4 SMBus driver");
437MODULE_LICENSE("GPL");