Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Input: add driver for Silead touchscreens
This driver adds support for Silead touchscreens. It has been tested
with GSL1680 and GSL3680 touch panels.
It supports ACPI and device tree enumeration. Screen resolution,
the maximum number of fingers supported and firmware name are
configurable.
Signed-off-by: Robert Dolca <robert.dolca@intel.com>
Signed-off-by: Daniel Jansen <djaniboe@gmail.com>
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Dmitry Torokhov <dmitry.torokhov@gmail.com>
authored by
Robert Dolca
and committed by
Dmitry Torokhov
3197704c
014420fe
+617
+36
Documentation/devicetree/bindings/input/touchscreen/silead_gsl1680.txt
+36
Documentation/devicetree/bindings/input/touchscreen/silead_gsl1680.txt
···
1
+
* GSL 1680 touchscreen controller
2
+
3
+
Required properties:
4
+
- compatible : "silead,gsl1680"
5
+
- reg : I2C slave address of the chip (0x40)
6
+
- interrupt-parent : a phandle pointing to the interrupt controller
7
+
serving the interrupt for this chip
8
+
- interrupts : interrupt specification for the gsl1680 interrupt
9
+
- power-gpios : Specification for the pin connected to the gsl1680's
10
+
shutdown input. This needs to be driven high to take the
11
+
gsl1680 out of its low power state
12
+
- touchscreen-size-x : See touchscreen.txt
13
+
- touchscreen-size-y : See touchscreen.txt
14
+
15
+
Optional properties:
16
+
- touchscreen-inverted-x : See touchscreen.txt
17
+
- touchscreen-inverted-y : See touchscreen.txt
18
+
- touchscreen-swapped-x-y : See touchscreen.txt
19
+
- silead,max-fingers : maximum number of fingers the touchscreen can detect
20
+
21
+
Example:
22
+
23
+
i2c@00000000 {
24
+
gsl1680: touchscreen@40 {
25
+
compatible = "silead,gsl1680";
26
+
reg = <0x40>;
27
+
interrupt-parent = <&pio>;
28
+
interrupts = <6 11 IRQ_TYPE_EDGE_FALLING>;
29
+
power-gpios = <&pio 1 3 GPIO_ACTIVE_HIGH>;
30
+
touchscreen-size-x = <480>;
31
+
touchscreen-size-y = <800>;
32
+
touchscreen-inverted-x;
33
+
touchscreen-swapped-x-y;
34
+
silead,max-fingers = <5>;
35
+
};
36
+
};
+12
drivers/input/touchscreen/Kconfig
+12
drivers/input/touchscreen/Kconfig
···
1059
1059
To compile this driver as a module, choose M here: the
1060
1060
module will be called raydium_i2c_ts.
1061
1061
1062
+
config TOUCHSCREEN_SILEAD
1063
+
tristate "Silead I2C touchscreen"
1064
+
depends on I2C
1065
+
help
1066
+
Say Y here if you have the Silead touchscreen connected to
1067
+
your system.
1068
+
1069
+
If unsure, say N.
1070
+
1071
+
To compile this driver as a module, choose M here: the
1072
+
module will be called silead.
1073
+
1062
1074
config TOUCHSCREEN_ST1232
1063
1075
tristate "Sitronix ST1232 touchscreen controllers"
1064
1076
depends on I2C
+1
drivers/input/touchscreen/Makefile
+1
drivers/input/touchscreen/Makefile
···
64
64
obj-$(CONFIG_TOUCHSCREEN_PIXCIR) += pixcir_i2c_ts.o
65
65
obj-$(CONFIG_TOUCHSCREEN_RM_TS) += raydium_i2c_ts.o
66
66
obj-$(CONFIG_TOUCHSCREEN_S3C2410) += s3c2410_ts.o
67
+
obj-$(CONFIG_TOUCHSCREEN_SILEAD) += silead.o
67
68
obj-$(CONFIG_TOUCHSCREEN_ST1232) += st1232.o
68
69
obj-$(CONFIG_TOUCHSCREEN_STMPE) += stmpe-ts.o
69
70
obj-$(CONFIG_TOUCHSCREEN_SUN4I) += sun4i-ts.o
+568
drivers/input/touchscreen/silead.c
+568
drivers/input/touchscreen/silead.c
···
1
+
/* -------------------------------------------------------------------------
2
+
* Copyright (C) 2014-2015, Intel Corporation
3
+
*
4
+
* Derived from:
5
+
* gslX68X.c
6
+
* Copyright (C) 2010-2015, Shanghai Sileadinc Co.Ltd
7
+
*
8
+
* This program is free software; you can redistribute it and/or modify
9
+
* it under the terms of the GNU General Public License as published by
10
+
* the Free Software Foundation; either version 2 of the License, or
11
+
* (at your option) any later version.
12
+
*
13
+
* This program is distributed in the hope that it will be useful,
14
+
* but WITHOUT ANY WARRANTY; without even the implied warranty of
15
+
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16
+
* GNU General Public License for more details.
17
+
* -------------------------------------------------------------------------
18
+
*/
19
+
20
+
#include <linux/i2c.h>
21
+
#include <linux/module.h>
22
+
#include <linux/acpi.h>
23
+
#include <linux/interrupt.h>
24
+
#include <linux/gpio/consumer.h>
25
+
#include <linux/delay.h>
26
+
#include <linux/firmware.h>
27
+
#include <linux/input.h>
28
+
#include <linux/input/mt.h>
29
+
#include <linux/input/touchscreen.h>
30
+
#include <linux/pm.h>
31
+
#include <linux/irq.h>
32
+
33
+
#include <asm/unaligned.h>
34
+
35
+
#define SILEAD_TS_NAME "silead_ts"
36
+
37
+
#define SILEAD_REG_RESET 0xE0
38
+
#define SILEAD_REG_DATA 0x80
39
+
#define SILEAD_REG_TOUCH_NR 0x80
40
+
#define SILEAD_REG_POWER 0xBC
41
+
#define SILEAD_REG_CLOCK 0xE4
42
+
#define SILEAD_REG_STATUS 0xB0
43
+
#define SILEAD_REG_ID 0xFC
44
+
#define SILEAD_REG_MEM_CHECK 0xB0
45
+
46
+
#define SILEAD_STATUS_OK 0x5A5A5A5A
47
+
#define SILEAD_TS_DATA_LEN 44
48
+
#define SILEAD_CLOCK 0x04
49
+
50
+
#define SILEAD_CMD_RESET 0x88
51
+
#define SILEAD_CMD_START 0x00
52
+
53
+
#define SILEAD_POINT_DATA_LEN 0x04
54
+
#define SILEAD_POINT_Y_OFF 0x00
55
+
#define SILEAD_POINT_Y_MSB_OFF 0x01
56
+
#define SILEAD_POINT_X_OFF 0x02
57
+
#define SILEAD_POINT_X_MSB_OFF 0x03
58
+
#define SILEAD_TOUCH_ID_MASK 0xF0
59
+
60
+
#define SILEAD_CMD_SLEEP_MIN 10000
61
+
#define SILEAD_CMD_SLEEP_MAX 20000
62
+
#define SILEAD_POWER_SLEEP 20
63
+
#define SILEAD_STARTUP_SLEEP 30
64
+
65
+
#define SILEAD_MAX_FINGERS 10
66
+
67
+
enum silead_ts_power {
68
+
SILEAD_POWER_ON = 1,
69
+
SILEAD_POWER_OFF = 0
70
+
};
71
+
72
+
struct silead_ts_data {
73
+
struct i2c_client *client;
74
+
struct gpio_desc *gpio_power;
75
+
struct input_dev *input;
76
+
char fw_name[64];
77
+
struct touchscreen_properties prop;
78
+
u32 max_fingers;
79
+
u32 chip_id;
80
+
struct input_mt_pos pos[SILEAD_MAX_FINGERS];
81
+
int slots[SILEAD_MAX_FINGERS];
82
+
int id[SILEAD_MAX_FINGERS];
83
+
};
84
+
85
+
struct silead_fw_data {
86
+
u32 offset;
87
+
u32 val;
88
+
};
89
+
90
+
static int silead_ts_request_input_dev(struct silead_ts_data *data)
91
+
{
92
+
struct device *dev = &data->client->dev;
93
+
int error;
94
+
95
+
data->input = devm_input_allocate_device(dev);
96
+
if (!data->input) {
97
+
dev_err(dev,
98
+
"Failed to allocate input device\n");
99
+
return -ENOMEM;
100
+
}
101
+
102
+
input_set_abs_params(data->input, ABS_MT_POSITION_X, 0, 4095, 0, 0);
103
+
input_set_abs_params(data->input, ABS_MT_POSITION_Y, 0, 4095, 0, 0);
104
+
touchscreen_parse_properties(data->input, true, &data->prop);
105
+
106
+
input_mt_init_slots(data->input, data->max_fingers,
107
+
INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED |
108
+
INPUT_MT_TRACK);
109
+
110
+
data->input->name = SILEAD_TS_NAME;
111
+
data->input->phys = "input/ts";
112
+
data->input->id.bustype = BUS_I2C;
113
+
114
+
error = input_register_device(data->input);
115
+
if (error) {
116
+
dev_err(dev, "Failed to register input device: %d\n", error);
117
+
return error;
118
+
}
119
+
120
+
return 0;
121
+
}
122
+
123
+
static void silead_ts_set_power(struct i2c_client *client,
124
+
enum silead_ts_power state)
125
+
{
126
+
struct silead_ts_data *data = i2c_get_clientdata(client);
127
+
128
+
if (data->gpio_power) {
129
+
gpiod_set_value_cansleep(data->gpio_power, state);
130
+
msleep(SILEAD_POWER_SLEEP);
131
+
}
132
+
}
133
+
134
+
static void silead_ts_read_data(struct i2c_client *client)
135
+
{
136
+
struct silead_ts_data *data = i2c_get_clientdata(client);
137
+
struct input_dev *input = data->input;
138
+
struct device *dev = &client->dev;
139
+
u8 *bufp, buf[SILEAD_TS_DATA_LEN];
140
+
int touch_nr, error, i;
141
+
142
+
error = i2c_smbus_read_i2c_block_data(client, SILEAD_REG_DATA,
143
+
SILEAD_TS_DATA_LEN, buf);
144
+
if (error < 0) {
145
+
dev_err(dev, "Data read error %d\n", error);
146
+
return;
147
+
}
148
+
149
+
touch_nr = buf[0];
150
+
if (touch_nr < 0)
151
+
return;
152
+
153
+
if (touch_nr > data->max_fingers) {
154
+
dev_warn(dev, "More touches reported then supported %d > %d\n",
155
+
touch_nr, data->max_fingers);
156
+
touch_nr = data->max_fingers;
157
+
}
158
+
159
+
bufp = buf + SILEAD_POINT_DATA_LEN;
160
+
for (i = 0; i < touch_nr; i++, bufp += SILEAD_POINT_DATA_LEN) {
161
+
/* Bits 4-7 are the touch id */
162
+
data->id[i] = (bufp[SILEAD_POINT_X_MSB_OFF] &
163
+
SILEAD_TOUCH_ID_MASK) >> 4;
164
+
touchscreen_set_mt_pos(&data->pos[i], &data->prop,
165
+
get_unaligned_le16(&bufp[SILEAD_POINT_X_OFF]) & 0xfff,
166
+
get_unaligned_le16(&bufp[SILEAD_POINT_Y_OFF]) & 0xfff);
167
+
}
168
+
169
+
input_mt_assign_slots(input, data->slots, data->pos, touch_nr, 0);
170
+
171
+
for (i = 0; i < touch_nr; i++) {
172
+
input_mt_slot(input, data->slots[i]);
173
+
input_mt_report_slot_state(input, MT_TOOL_FINGER, true);
174
+
input_report_abs(input, ABS_MT_POSITION_X, data->pos[i].x);
175
+
input_report_abs(input, ABS_MT_POSITION_Y, data->pos[i].y);
176
+
177
+
dev_dbg(dev, "x=%d y=%d hw_id=%d sw_id=%d\n", data->pos[i].x,
178
+
data->pos[i].y, data->id[i], data->slots[i]);
179
+
}
180
+
181
+
input_mt_sync_frame(input);
182
+
input_sync(input);
183
+
}
184
+
185
+
static int silead_ts_init(struct i2c_client *client)
186
+
{
187
+
struct silead_ts_data *data = i2c_get_clientdata(client);
188
+
int error;
189
+
190
+
error = i2c_smbus_write_byte_data(client, SILEAD_REG_RESET,
191
+
SILEAD_CMD_RESET);
192
+
if (error)
193
+
goto i2c_write_err;
194
+
usleep_range(SILEAD_CMD_SLEEP_MIN, SILEAD_CMD_SLEEP_MAX);
195
+
196
+
error = i2c_smbus_write_byte_data(client, SILEAD_REG_TOUCH_NR,
197
+
data->max_fingers);
198
+
if (error)
199
+
goto i2c_write_err;
200
+
usleep_range(SILEAD_CMD_SLEEP_MIN, SILEAD_CMD_SLEEP_MAX);
201
+
202
+
error = i2c_smbus_write_byte_data(client, SILEAD_REG_CLOCK,
203
+
SILEAD_CLOCK);
204
+
if (error)
205
+
goto i2c_write_err;
206
+
usleep_range(SILEAD_CMD_SLEEP_MIN, SILEAD_CMD_SLEEP_MAX);
207
+
208
+
error = i2c_smbus_write_byte_data(client, SILEAD_REG_RESET,
209
+
SILEAD_CMD_START);
210
+
if (error)
211
+
goto i2c_write_err;
212
+
usleep_range(SILEAD_CMD_SLEEP_MIN, SILEAD_CMD_SLEEP_MAX);
213
+
214
+
return 0;
215
+
216
+
i2c_write_err:
217
+
dev_err(&client->dev, "Registers clear error %d\n", error);
218
+
return error;
219
+
}
220
+
221
+
static int silead_ts_reset(struct i2c_client *client)
222
+
{
223
+
int error;
224
+
225
+
error = i2c_smbus_write_byte_data(client, SILEAD_REG_RESET,
226
+
SILEAD_CMD_RESET);
227
+
if (error)
228
+
goto i2c_write_err;
229
+
usleep_range(SILEAD_CMD_SLEEP_MIN, SILEAD_CMD_SLEEP_MAX);
230
+
231
+
error = i2c_smbus_write_byte_data(client, SILEAD_REG_CLOCK,
232
+
SILEAD_CLOCK);
233
+
if (error)
234
+
goto i2c_write_err;
235
+
usleep_range(SILEAD_CMD_SLEEP_MIN, SILEAD_CMD_SLEEP_MAX);
236
+
237
+
error = i2c_smbus_write_byte_data(client, SILEAD_REG_POWER,
238
+
SILEAD_CMD_START);
239
+
if (error)
240
+
goto i2c_write_err;
241
+
usleep_range(SILEAD_CMD_SLEEP_MIN, SILEAD_CMD_SLEEP_MAX);
242
+
243
+
return 0;
244
+
245
+
i2c_write_err:
246
+
dev_err(&client->dev, "Chip reset error %d\n", error);
247
+
return error;
248
+
}
249
+
250
+
static int silead_ts_startup(struct i2c_client *client)
251
+
{
252
+
int error;
253
+
254
+
error = i2c_smbus_write_byte_data(client, SILEAD_REG_RESET, 0x00);
255
+
if (error) {
256
+
dev_err(&client->dev, "Startup error %d\n", error);
257
+
return error;
258
+
}
259
+
260
+
msleep(SILEAD_STARTUP_SLEEP);
261
+
262
+
return 0;
263
+
}
264
+
265
+
static int silead_ts_load_fw(struct i2c_client *client)
266
+
{
267
+
struct device *dev = &client->dev;
268
+
struct silead_ts_data *data = i2c_get_clientdata(client);
269
+
unsigned int fw_size, i;
270
+
const struct firmware *fw;
271
+
struct silead_fw_data *fw_data;
272
+
int error;
273
+
274
+
dev_dbg(dev, "Firmware file name: %s", data->fw_name);
275
+
276
+
error = request_firmware(&fw, data->fw_name, dev);
277
+
if (error) {
278
+
dev_err(dev, "Firmware request error %d\n", error);
279
+
return error;
280
+
}
281
+
282
+
fw_size = fw->size / sizeof(*fw_data);
283
+
fw_data = (struct silead_fw_data *)fw->data;
284
+
285
+
for (i = 0; i < fw_size; i++) {
286
+
error = i2c_smbus_write_i2c_block_data(client,
287
+
fw_data[i].offset,
288
+
4,
289
+
(u8 *)&fw_data[i].val);
290
+
if (error) {
291
+
dev_err(dev, "Firmware load error %d\n", error);
292
+
break;
293
+
}
294
+
}
295
+
296
+
release_firmware(fw);
297
+
return error ?: 0;
298
+
}
299
+
300
+
static u32 silead_ts_get_status(struct i2c_client *client)
301
+
{
302
+
int error;
303
+
__le32 status;
304
+
305
+
error = i2c_smbus_read_i2c_block_data(client, SILEAD_REG_STATUS,
306
+
sizeof(status), (u8 *)&status);
307
+
if (error < 0) {
308
+
dev_err(&client->dev, "Status read error %d\n", error);
309
+
return error;
310
+
}
311
+
312
+
return le32_to_cpu(status);
313
+
}
314
+
315
+
static int silead_ts_get_id(struct i2c_client *client)
316
+
{
317
+
struct silead_ts_data *data = i2c_get_clientdata(client);
318
+
__le32 chip_id;
319
+
int error;
320
+
321
+
error = i2c_smbus_read_i2c_block_data(client, SILEAD_REG_ID,
322
+
sizeof(chip_id), (u8 *)&chip_id);
323
+
if (error < 0) {
324
+
dev_err(&client->dev, "Chip ID read error %d\n", error);
325
+
return error;
326
+
}
327
+
328
+
data->chip_id = le32_to_cpu(chip_id);
329
+
dev_info(&client->dev, "Silead chip ID: 0x%8X", data->chip_id);
330
+
331
+
return 0;
332
+
}
333
+
334
+
static int silead_ts_setup(struct i2c_client *client)
335
+
{
336
+
int error;
337
+
u32 status;
338
+
339
+
silead_ts_set_power(client, SILEAD_POWER_OFF);
340
+
silead_ts_set_power(client, SILEAD_POWER_ON);
341
+
342
+
error = silead_ts_get_id(client);
343
+
if (error)
344
+
return error;
345
+
346
+
error = silead_ts_init(client);
347
+
if (error)
348
+
return error;
349
+
350
+
error = silead_ts_reset(client);
351
+
if (error)
352
+
return error;
353
+
354
+
error = silead_ts_load_fw(client);
355
+
if (error)
356
+
return error;
357
+
358
+
error = silead_ts_startup(client);
359
+
if (error)
360
+
return error;
361
+
362
+
status = silead_ts_get_status(client);
363
+
if (status != SILEAD_STATUS_OK) {
364
+
dev_err(&client->dev,
365
+
"Initialization error, status: 0x%X\n", status);
366
+
return -ENODEV;
367
+
}
368
+
369
+
return 0;
370
+
}
371
+
372
+
static irqreturn_t silead_ts_threaded_irq_handler(int irq, void *id)
373
+
{
374
+
struct silead_ts_data *data = id;
375
+
struct i2c_client *client = data->client;
376
+
377
+
silead_ts_read_data(client);
378
+
379
+
return IRQ_HANDLED;
380
+
}
381
+
382
+
static void silead_ts_read_props(struct i2c_client *client)
383
+
{
384
+
struct silead_ts_data *data = i2c_get_clientdata(client);
385
+
struct device *dev = &client->dev;
386
+
const char *str;
387
+
int error;
388
+
389
+
error = device_property_read_u32(dev, "silead,max-fingers",
390
+
&data->max_fingers);
391
+
if (error) {
392
+
dev_dbg(dev, "Max fingers read error %d\n", error);
393
+
data->max_fingers = 5; /* Most devices handle up-to 5 fingers */
394
+
}
395
+
396
+
error = device_property_read_string(dev, "touchscreen-fw-name", &str);
397
+
if (!error)
398
+
snprintf(data->fw_name, sizeof(data->fw_name), "%s", str);
399
+
else
400
+
dev_dbg(dev, "Firmware file name read error. Using default.");
401
+
}
402
+
403
+
#ifdef CONFIG_ACPI
404
+
static int silead_ts_set_default_fw_name(struct silead_ts_data *data,
405
+
const struct i2c_device_id *id)
406
+
{
407
+
const struct acpi_device_id *acpi_id;
408
+
struct device *dev = &data->client->dev;
409
+
int i;
410
+
411
+
if (ACPI_HANDLE(dev)) {
412
+
acpi_id = acpi_match_device(dev->driver->acpi_match_table, dev);
413
+
if (!acpi_id)
414
+
return -ENODEV;
415
+
416
+
snprintf(data->fw_name, sizeof(data->fw_name), "%s.fw",
417
+
acpi_id->id);
418
+
419
+
for (i = 0; i < strlen(data->fw_name); i++)
420
+
data->fw_name[i] = tolower(data->fw_name[i]);
421
+
} else {
422
+
snprintf(data->fw_name, sizeof(data->fw_name), "%s.fw",
423
+
id->name);
424
+
}
425
+
426
+
return 0;
427
+
}
428
+
#else
429
+
static int silead_ts_set_default_fw_name(struct silead_ts_data *data,
430
+
const struct i2c_device_id *id)
431
+
{
432
+
snprintf(data->fw_name, sizeof(data->fw_name), "%s.fw", id->name);
433
+
return 0;
434
+
}
435
+
#endif
436
+
437
+
static int silead_ts_probe(struct i2c_client *client,
438
+
const struct i2c_device_id *id)
439
+
{
440
+
struct silead_ts_data *data;
441
+
struct device *dev = &client->dev;
442
+
int error;
443
+
444
+
if (!i2c_check_functionality(client->adapter,
445
+
I2C_FUNC_I2C |
446
+
I2C_FUNC_SMBUS_READ_I2C_BLOCK |
447
+
I2C_FUNC_SMBUS_WRITE_I2C_BLOCK)) {
448
+
dev_err(dev, "I2C functionality check failed\n");
449
+
return -ENXIO;
450
+
}
451
+
452
+
data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
453
+
if (!data)
454
+
return -ENOMEM;
455
+
456
+
i2c_set_clientdata(client, data);
457
+
data->client = client;
458
+
459
+
error = silead_ts_set_default_fw_name(data, id);
460
+
if (error)
461
+
return error;
462
+
463
+
silead_ts_read_props(client);
464
+
465
+
/* We must have the IRQ provided by DT or ACPI subsytem */
466
+
if (client->irq <= 0)
467
+
return -ENODEV;
468
+
469
+
/* Power GPIO pin */
470
+
data->gpio_power = gpiod_get_optional(dev, "power", GPIOD_OUT_LOW);
471
+
if (IS_ERR(data->gpio_power)) {
472
+
if (PTR_ERR(data->gpio_power) != -EPROBE_DEFER)
473
+
dev_err(dev, "Shutdown GPIO request failed\n");
474
+
return PTR_ERR(data->gpio_power);
475
+
}
476
+
477
+
error = silead_ts_setup(client);
478
+
if (error)
479
+
return error;
480
+
481
+
error = silead_ts_request_input_dev(data);
482
+
if (error)
483
+
return error;
484
+
485
+
error = devm_request_threaded_irq(dev, client->irq,
486
+
NULL, silead_ts_threaded_irq_handler,
487
+
IRQF_ONESHOT, client->name, data);
488
+
if (error) {
489
+
if (error != -EPROBE_DEFER)
490
+
dev_err(dev, "IRQ request failed %d\n", error);
491
+
return error;
492
+
}
493
+
494
+
return 0;
495
+
}
496
+
497
+
static int __maybe_unused silead_ts_suspend(struct device *dev)
498
+
{
499
+
struct i2c_client *client = to_i2c_client(dev);
500
+
501
+
silead_ts_set_power(client, SILEAD_POWER_OFF);
502
+
return 0;
503
+
}
504
+
505
+
static int __maybe_unused silead_ts_resume(struct device *dev)
506
+
{
507
+
struct i2c_client *client = to_i2c_client(dev);
508
+
int error, status;
509
+
510
+
silead_ts_set_power(client, SILEAD_POWER_ON);
511
+
512
+
error = silead_ts_reset(client);
513
+
if (error)
514
+
return error;
515
+
516
+
error = silead_ts_startup(client);
517
+
if (error)
518
+
return error;
519
+
520
+
status = silead_ts_get_status(client);
521
+
if (status != SILEAD_STATUS_OK) {
522
+
dev_err(dev, "Resume error, status: 0x%02x\n", status);
523
+
return -ENODEV;
524
+
}
525
+
526
+
return 0;
527
+
}
528
+
529
+
static SIMPLE_DEV_PM_OPS(silead_ts_pm, silead_ts_suspend, silead_ts_resume);
530
+
531
+
static const struct i2c_device_id silead_ts_id[] = {
532
+
{ "gsl1680", 0 },
533
+
{ "gsl1688", 0 },
534
+
{ "gsl3670", 0 },
535
+
{ "gsl3675", 0 },
536
+
{ "gsl3692", 0 },
537
+
{ "mssl1680", 0 },
538
+
{ }
539
+
};
540
+
MODULE_DEVICE_TABLE(i2c, silead_ts_id);
541
+
542
+
#ifdef CONFIG_ACPI
543
+
static const struct acpi_device_id silead_ts_acpi_match[] = {
544
+
{ "GSL1680", 0 },
545
+
{ "GSL1688", 0 },
546
+
{ "GSL3670", 0 },
547
+
{ "GSL3675", 0 },
548
+
{ "GSL3692", 0 },
549
+
{ "MSSL1680", 0 },
550
+
{ }
551
+
};
552
+
MODULE_DEVICE_TABLE(acpi, silead_ts_acpi_match);
553
+
#endif
554
+
555
+
static struct i2c_driver silead_ts_driver = {
556
+
.probe = silead_ts_probe,
557
+
.id_table = silead_ts_id,
558
+
.driver = {
559
+
.name = SILEAD_TS_NAME,
560
+
.acpi_match_table = ACPI_PTR(silead_ts_acpi_match),
561
+
.pm = &silead_ts_pm,
562
+
},
563
+
};
564
+
module_i2c_driver(silead_ts_driver);
565
+
566
+
MODULE_AUTHOR("Robert Dolca <robert.dolca@intel.com>");
567
+
MODULE_DESCRIPTION("Silead I2C touchscreen driver");
568
+
MODULE_LICENSE("GPL");