Heiko Stübner | c6d81bd | 2013-10-31 01:25:32 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2012-2013 MundoReader S.L. |
| 3 | * Author: Heiko Stuebner <heiko@sntech.de> |
| 4 | * |
| 5 | * based in parts on Nook zforce driver |
| 6 | * |
| 7 | * Copyright (C) 2010 Barnes & Noble, Inc. |
| 8 | * Author: Pieter Truter<ptruter@intrinsyc.com> |
| 9 | * |
| 10 | * This software is licensed under the terms of the GNU General Public |
| 11 | * License version 2, as published by the Free Software Foundation, and |
| 12 | * may be copied, distributed, and modified under those terms. |
| 13 | * |
| 14 | * This program is distributed in the hope that it will be useful, |
| 15 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 17 | * GNU General Public License for more details. |
| 18 | */ |
| 19 | |
| 20 | #include <linux/module.h> |
| 21 | #include <linux/hrtimer.h> |
| 22 | #include <linux/slab.h> |
| 23 | #include <linux/input.h> |
| 24 | #include <linux/interrupt.h> |
| 25 | #include <linux/i2c.h> |
| 26 | #include <linux/delay.h> |
Dirk Behme | 2d53809 | 2015-07-06 15:57:44 -0700 | [diff] [blame] | 27 | #include <linux/gpio/consumer.h> |
Heiko Stübner | c6d81bd | 2013-10-31 01:25:32 -0700 | [diff] [blame] | 28 | #include <linux/device.h> |
| 29 | #include <linux/sysfs.h> |
| 30 | #include <linux/input/mt.h> |
| 31 | #include <linux/platform_data/zforce_ts.h> |
Heiko Stuebner | 3974037 | 2014-07-21 10:02:11 -0700 | [diff] [blame] | 32 | #include <linux/regulator/consumer.h> |
Heiko Stübner | 6f2e6c9 | 2014-01-27 12:37:21 -0800 | [diff] [blame] | 33 | #include <linux/of.h> |
Heiko Stübner | c6d81bd | 2013-10-31 01:25:32 -0700 | [diff] [blame] | 34 | |
| 35 | #define WAIT_TIMEOUT msecs_to_jiffies(1000) |
| 36 | |
| 37 | #define FRAME_START 0xee |
Luis Ortega | d333b60 | 2014-01-27 12:28:33 -0800 | [diff] [blame] | 38 | #define FRAME_MAXSIZE 257 |
Heiko Stübner | c6d81bd | 2013-10-31 01:25:32 -0700 | [diff] [blame] | 39 | |
| 40 | /* Offsets of the different parts of the payload the controller sends */ |
| 41 | #define PAYLOAD_HEADER 0 |
| 42 | #define PAYLOAD_LENGTH 1 |
| 43 | #define PAYLOAD_BODY 2 |
| 44 | |
| 45 | /* Response offsets */ |
| 46 | #define RESPONSE_ID 0 |
| 47 | #define RESPONSE_DATA 1 |
| 48 | |
| 49 | /* Commands */ |
| 50 | #define COMMAND_DEACTIVATE 0x00 |
| 51 | #define COMMAND_INITIALIZE 0x01 |
| 52 | #define COMMAND_RESOLUTION 0x02 |
| 53 | #define COMMAND_SETCONFIG 0x03 |
| 54 | #define COMMAND_DATAREQUEST 0x04 |
| 55 | #define COMMAND_SCANFREQ 0x08 |
| 56 | #define COMMAND_STATUS 0X1e |
| 57 | |
| 58 | /* |
| 59 | * Responses the controller sends as a result of |
| 60 | * command requests |
| 61 | */ |
| 62 | #define RESPONSE_DEACTIVATE 0x00 |
| 63 | #define RESPONSE_INITIALIZE 0x01 |
| 64 | #define RESPONSE_RESOLUTION 0x02 |
| 65 | #define RESPONSE_SETCONFIG 0x03 |
| 66 | #define RESPONSE_SCANFREQ 0x08 |
| 67 | #define RESPONSE_STATUS 0X1e |
| 68 | |
| 69 | /* |
Luis Ortega | deb4981 | 2014-01-27 12:27:06 -0800 | [diff] [blame] | 70 | * Notifications are sent by the touch controller without |
Heiko Stübner | c6d81bd | 2013-10-31 01:25:32 -0700 | [diff] [blame] | 71 | * being requested by the driver and include for example |
| 72 | * touch indications |
| 73 | */ |
| 74 | #define NOTIFICATION_TOUCH 0x04 |
| 75 | #define NOTIFICATION_BOOTCOMPLETE 0x07 |
| 76 | #define NOTIFICATION_OVERRUN 0x25 |
| 77 | #define NOTIFICATION_PROXIMITY 0x26 |
| 78 | #define NOTIFICATION_INVALID_COMMAND 0xfe |
| 79 | |
| 80 | #define ZFORCE_REPORT_POINTS 2 |
| 81 | #define ZFORCE_MAX_AREA 0xff |
| 82 | |
| 83 | #define STATE_DOWN 0 |
| 84 | #define STATE_MOVE 1 |
| 85 | #define STATE_UP 2 |
| 86 | |
| 87 | #define SETCONFIG_DUALTOUCH (1 << 0) |
| 88 | |
| 89 | struct zforce_point { |
| 90 | int coord_x; |
| 91 | int coord_y; |
| 92 | int state; |
| 93 | int id; |
| 94 | int area_major; |
| 95 | int area_minor; |
| 96 | int orientation; |
| 97 | int pressure; |
| 98 | int prblty; |
| 99 | }; |
| 100 | |
| 101 | /* |
| 102 | * @client the i2c_client |
| 103 | * @input the input device |
| 104 | * @suspending in the process of going to suspend (don't emit wakeup |
| 105 | * events for commands executed to suspend the device) |
| 106 | * @suspended device suspended |
| 107 | * @access_mutex serialize i2c-access, to keep multipart reads together |
| 108 | * @command_done completion to wait for the command result |
Luis Ortega | deb4981 | 2014-01-27 12:27:06 -0800 | [diff] [blame] | 109 | * @command_mutex serialize commands sent to the ic |
| 110 | * @command_waiting the id of the command that is currently waiting |
Heiko Stübner | c6d81bd | 2013-10-31 01:25:32 -0700 | [diff] [blame] | 111 | * for a result |
| 112 | * @command_result returned result of the command |
| 113 | */ |
| 114 | struct zforce_ts { |
| 115 | struct i2c_client *client; |
| 116 | struct input_dev *input; |
| 117 | const struct zforce_ts_platdata *pdata; |
| 118 | char phys[32]; |
| 119 | |
Heiko Stuebner | 3974037 | 2014-07-21 10:02:11 -0700 | [diff] [blame] | 120 | struct regulator *reg_vdd; |
| 121 | |
Dirk Behme | 2d53809 | 2015-07-06 15:57:44 -0700 | [diff] [blame] | 122 | struct gpio_desc *gpio_int; |
| 123 | struct gpio_desc *gpio_rst; |
| 124 | |
Heiko Stübner | c6d81bd | 2013-10-31 01:25:32 -0700 | [diff] [blame] | 125 | bool suspending; |
| 126 | bool suspended; |
| 127 | bool boot_complete; |
| 128 | |
| 129 | /* Firmware version information */ |
| 130 | u16 version_major; |
| 131 | u16 version_minor; |
| 132 | u16 version_build; |
| 133 | u16 version_rev; |
| 134 | |
| 135 | struct mutex access_mutex; |
| 136 | |
| 137 | struct completion command_done; |
| 138 | struct mutex command_mutex; |
| 139 | int command_waiting; |
| 140 | int command_result; |
| 141 | }; |
| 142 | |
| 143 | static int zforce_command(struct zforce_ts *ts, u8 cmd) |
| 144 | { |
| 145 | struct i2c_client *client = ts->client; |
| 146 | char buf[3]; |
| 147 | int ret; |
| 148 | |
| 149 | dev_dbg(&client->dev, "%s: 0x%x\n", __func__, cmd); |
| 150 | |
| 151 | buf[0] = FRAME_START; |
| 152 | buf[1] = 1; /* data size, command only */ |
| 153 | buf[2] = cmd; |
| 154 | |
| 155 | mutex_lock(&ts->access_mutex); |
| 156 | ret = i2c_master_send(client, &buf[0], ARRAY_SIZE(buf)); |
| 157 | mutex_unlock(&ts->access_mutex); |
| 158 | if (ret < 0) { |
| 159 | dev_err(&client->dev, "i2c send data request error: %d\n", ret); |
| 160 | return ret; |
| 161 | } |
| 162 | |
| 163 | return 0; |
| 164 | } |
| 165 | |
Dirk Behme | 2d53809 | 2015-07-06 15:57:44 -0700 | [diff] [blame] | 166 | static void zforce_reset_assert(struct zforce_ts *ts) |
| 167 | { |
| 168 | gpiod_set_value_cansleep(ts->gpio_rst, 1); |
| 169 | } |
| 170 | |
| 171 | static void zforce_reset_deassert(struct zforce_ts *ts) |
| 172 | { |
| 173 | gpiod_set_value_cansleep(ts->gpio_rst, 0); |
| 174 | } |
| 175 | |
Heiko Stübner | c6d81bd | 2013-10-31 01:25:32 -0700 | [diff] [blame] | 176 | static int zforce_send_wait(struct zforce_ts *ts, const char *buf, int len) |
| 177 | { |
| 178 | struct i2c_client *client = ts->client; |
| 179 | int ret; |
| 180 | |
| 181 | ret = mutex_trylock(&ts->command_mutex); |
| 182 | if (!ret) { |
| 183 | dev_err(&client->dev, "already waiting for a command\n"); |
| 184 | return -EBUSY; |
| 185 | } |
| 186 | |
| 187 | dev_dbg(&client->dev, "sending %d bytes for command 0x%x\n", |
| 188 | buf[1], buf[2]); |
| 189 | |
| 190 | ts->command_waiting = buf[2]; |
| 191 | |
| 192 | mutex_lock(&ts->access_mutex); |
| 193 | ret = i2c_master_send(client, buf, len); |
| 194 | mutex_unlock(&ts->access_mutex); |
| 195 | if (ret < 0) { |
| 196 | dev_err(&client->dev, "i2c send data request error: %d\n", ret); |
| 197 | goto unlock; |
| 198 | } |
| 199 | |
| 200 | dev_dbg(&client->dev, "waiting for result for command 0x%x\n", buf[2]); |
| 201 | |
| 202 | if (wait_for_completion_timeout(&ts->command_done, WAIT_TIMEOUT) == 0) { |
| 203 | ret = -ETIME; |
| 204 | goto unlock; |
| 205 | } |
| 206 | |
| 207 | ret = ts->command_result; |
| 208 | |
| 209 | unlock: |
| 210 | mutex_unlock(&ts->command_mutex); |
| 211 | return ret; |
| 212 | } |
| 213 | |
| 214 | static int zforce_command_wait(struct zforce_ts *ts, u8 cmd) |
| 215 | { |
| 216 | struct i2c_client *client = ts->client; |
| 217 | char buf[3]; |
| 218 | int ret; |
| 219 | |
| 220 | dev_dbg(&client->dev, "%s: 0x%x\n", __func__, cmd); |
| 221 | |
| 222 | buf[0] = FRAME_START; |
| 223 | buf[1] = 1; /* data size, command only */ |
| 224 | buf[2] = cmd; |
| 225 | |
| 226 | ret = zforce_send_wait(ts, &buf[0], ARRAY_SIZE(buf)); |
| 227 | if (ret < 0) { |
| 228 | dev_err(&client->dev, "i2c send data request error: %d\n", ret); |
| 229 | return ret; |
| 230 | } |
| 231 | |
| 232 | return 0; |
| 233 | } |
| 234 | |
| 235 | static int zforce_resolution(struct zforce_ts *ts, u16 x, u16 y) |
| 236 | { |
| 237 | struct i2c_client *client = ts->client; |
| 238 | char buf[7] = { FRAME_START, 5, COMMAND_RESOLUTION, |
| 239 | (x & 0xff), ((x >> 8) & 0xff), |
| 240 | (y & 0xff), ((y >> 8) & 0xff) }; |
| 241 | |
| 242 | dev_dbg(&client->dev, "set resolution to (%d,%d)\n", x, y); |
| 243 | |
| 244 | return zforce_send_wait(ts, &buf[0], ARRAY_SIZE(buf)); |
| 245 | } |
| 246 | |
| 247 | static int zforce_scan_frequency(struct zforce_ts *ts, u16 idle, u16 finger, |
| 248 | u16 stylus) |
| 249 | { |
| 250 | struct i2c_client *client = ts->client; |
| 251 | char buf[9] = { FRAME_START, 7, COMMAND_SCANFREQ, |
| 252 | (idle & 0xff), ((idle >> 8) & 0xff), |
| 253 | (finger & 0xff), ((finger >> 8) & 0xff), |
| 254 | (stylus & 0xff), ((stylus >> 8) & 0xff) }; |
| 255 | |
Luis Ortega | ad697b9 | 2014-01-27 12:27:35 -0800 | [diff] [blame] | 256 | dev_dbg(&client->dev, |
| 257 | "set scan frequency to (idle: %d, finger: %d, stylus: %d)\n", |
Heiko Stübner | c6d81bd | 2013-10-31 01:25:32 -0700 | [diff] [blame] | 258 | idle, finger, stylus); |
| 259 | |
| 260 | return zforce_send_wait(ts, &buf[0], ARRAY_SIZE(buf)); |
| 261 | } |
| 262 | |
| 263 | static int zforce_setconfig(struct zforce_ts *ts, char b1) |
| 264 | { |
| 265 | struct i2c_client *client = ts->client; |
| 266 | char buf[7] = { FRAME_START, 5, COMMAND_SETCONFIG, |
| 267 | b1, 0, 0, 0 }; |
| 268 | |
| 269 | dev_dbg(&client->dev, "set config to (%d)\n", b1); |
| 270 | |
| 271 | return zforce_send_wait(ts, &buf[0], ARRAY_SIZE(buf)); |
| 272 | } |
| 273 | |
| 274 | static int zforce_start(struct zforce_ts *ts) |
| 275 | { |
| 276 | struct i2c_client *client = ts->client; |
Heiko Stübner | 8727336 | 2014-01-27 12:32:38 -0800 | [diff] [blame] | 277 | const struct zforce_ts_platdata *pdata = ts->pdata; |
Heiko Stübner | c6d81bd | 2013-10-31 01:25:32 -0700 | [diff] [blame] | 278 | int ret; |
| 279 | |
| 280 | dev_dbg(&client->dev, "starting device\n"); |
| 281 | |
| 282 | ret = zforce_command_wait(ts, COMMAND_INITIALIZE); |
| 283 | if (ret) { |
| 284 | dev_err(&client->dev, "Unable to initialize, %d\n", ret); |
| 285 | return ret; |
| 286 | } |
| 287 | |
| 288 | ret = zforce_resolution(ts, pdata->x_max, pdata->y_max); |
| 289 | if (ret) { |
| 290 | dev_err(&client->dev, "Unable to set resolution, %d\n", ret); |
| 291 | goto error; |
| 292 | } |
| 293 | |
| 294 | ret = zforce_scan_frequency(ts, 10, 50, 50); |
| 295 | if (ret) { |
| 296 | dev_err(&client->dev, "Unable to set scan frequency, %d\n", |
| 297 | ret); |
| 298 | goto error; |
| 299 | } |
| 300 | |
Wei Yongjun | 3c4396b | 2013-12-17 08:58:18 -0800 | [diff] [blame] | 301 | ret = zforce_setconfig(ts, SETCONFIG_DUALTOUCH); |
| 302 | if (ret) { |
Heiko Stübner | c6d81bd | 2013-10-31 01:25:32 -0700 | [diff] [blame] | 303 | dev_err(&client->dev, "Unable to set config\n"); |
| 304 | goto error; |
| 305 | } |
| 306 | |
| 307 | /* start sending touch events */ |
| 308 | ret = zforce_command(ts, COMMAND_DATAREQUEST); |
| 309 | if (ret) { |
| 310 | dev_err(&client->dev, "Unable to request data\n"); |
| 311 | goto error; |
| 312 | } |
| 313 | |
| 314 | /* |
| 315 | * Per NN, initial cal. take max. of 200msec. |
| 316 | * Allow time to complete this calibration |
| 317 | */ |
| 318 | msleep(200); |
| 319 | |
| 320 | return 0; |
| 321 | |
| 322 | error: |
| 323 | zforce_command_wait(ts, COMMAND_DEACTIVATE); |
| 324 | return ret; |
| 325 | } |
| 326 | |
| 327 | static int zforce_stop(struct zforce_ts *ts) |
| 328 | { |
| 329 | struct i2c_client *client = ts->client; |
| 330 | int ret; |
| 331 | |
| 332 | dev_dbg(&client->dev, "stopping device\n"); |
| 333 | |
| 334 | /* Deactivates touch sensing and puts the device into sleep. */ |
| 335 | ret = zforce_command_wait(ts, COMMAND_DEACTIVATE); |
| 336 | if (ret != 0) { |
| 337 | dev_err(&client->dev, "could not deactivate device, %d\n", |
| 338 | ret); |
| 339 | return ret; |
| 340 | } |
| 341 | |
| 342 | return 0; |
| 343 | } |
| 344 | |
| 345 | static int zforce_touch_event(struct zforce_ts *ts, u8 *payload) |
| 346 | { |
| 347 | struct i2c_client *client = ts->client; |
Heiko Stübner | 8727336 | 2014-01-27 12:32:38 -0800 | [diff] [blame] | 348 | const struct zforce_ts_platdata *pdata = ts->pdata; |
Heiko Stübner | c6d81bd | 2013-10-31 01:25:32 -0700 | [diff] [blame] | 349 | struct zforce_point point; |
| 350 | int count, i, num = 0; |
| 351 | |
| 352 | count = payload[0]; |
| 353 | if (count > ZFORCE_REPORT_POINTS) { |
Luis Ortega | ad697b9 | 2014-01-27 12:27:35 -0800 | [diff] [blame] | 354 | dev_warn(&client->dev, |
| 355 | "too many coordinates %d, expected max %d\n", |
Heiko Stübner | c6d81bd | 2013-10-31 01:25:32 -0700 | [diff] [blame] | 356 | count, ZFORCE_REPORT_POINTS); |
| 357 | count = ZFORCE_REPORT_POINTS; |
| 358 | } |
| 359 | |
| 360 | for (i = 0; i < count; i++) { |
| 361 | point.coord_x = |
| 362 | payload[9 * i + 2] << 8 | payload[9 * i + 1]; |
| 363 | point.coord_y = |
| 364 | payload[9 * i + 4] << 8 | payload[9 * i + 3]; |
| 365 | |
| 366 | if (point.coord_x > pdata->x_max || |
| 367 | point.coord_y > pdata->y_max) { |
| 368 | dev_warn(&client->dev, "coordinates (%d,%d) invalid\n", |
| 369 | point.coord_x, point.coord_y); |
| 370 | point.coord_x = point.coord_y = 0; |
| 371 | } |
| 372 | |
| 373 | point.state = payload[9 * i + 5] & 0x03; |
| 374 | point.id = (payload[9 * i + 5] & 0xfc) >> 2; |
| 375 | |
| 376 | /* determine touch major, minor and orientation */ |
| 377 | point.area_major = max(payload[9 * i + 6], |
| 378 | payload[9 * i + 7]); |
| 379 | point.area_minor = min(payload[9 * i + 6], |
| 380 | payload[9 * i + 7]); |
| 381 | point.orientation = payload[9 * i + 6] > payload[9 * i + 7]; |
| 382 | |
| 383 | point.pressure = payload[9 * i + 8]; |
| 384 | point.prblty = payload[9 * i + 9]; |
| 385 | |
| 386 | dev_dbg(&client->dev, |
| 387 | "point %d/%d: state %d, id %d, pressure %d, prblty %d, x %d, y %d, amajor %d, aminor %d, ori %d\n", |
| 388 | i, count, point.state, point.id, |
| 389 | point.pressure, point.prblty, |
| 390 | point.coord_x, point.coord_y, |
| 391 | point.area_major, point.area_minor, |
| 392 | point.orientation); |
| 393 | |
| 394 | /* the zforce id starts with "1", so needs to be decreased */ |
| 395 | input_mt_slot(ts->input, point.id - 1); |
| 396 | |
| 397 | input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, |
| 398 | point.state != STATE_UP); |
| 399 | |
| 400 | if (point.state != STATE_UP) { |
| 401 | input_report_abs(ts->input, ABS_MT_POSITION_X, |
| 402 | point.coord_x); |
| 403 | input_report_abs(ts->input, ABS_MT_POSITION_Y, |
| 404 | point.coord_y); |
| 405 | input_report_abs(ts->input, ABS_MT_TOUCH_MAJOR, |
| 406 | point.area_major); |
| 407 | input_report_abs(ts->input, ABS_MT_TOUCH_MINOR, |
| 408 | point.area_minor); |
| 409 | input_report_abs(ts->input, ABS_MT_ORIENTATION, |
| 410 | point.orientation); |
| 411 | num++; |
| 412 | } |
| 413 | } |
| 414 | |
| 415 | input_mt_sync_frame(ts->input); |
| 416 | |
| 417 | input_mt_report_finger_count(ts->input, num); |
| 418 | |
| 419 | input_sync(ts->input); |
| 420 | |
| 421 | return 0; |
| 422 | } |
| 423 | |
| 424 | static int zforce_read_packet(struct zforce_ts *ts, u8 *buf) |
| 425 | { |
| 426 | struct i2c_client *client = ts->client; |
| 427 | int ret; |
| 428 | |
| 429 | mutex_lock(&ts->access_mutex); |
| 430 | |
| 431 | /* read 2 byte message header */ |
| 432 | ret = i2c_master_recv(client, buf, 2); |
| 433 | if (ret < 0) { |
| 434 | dev_err(&client->dev, "error reading header: %d\n", ret); |
| 435 | goto unlock; |
| 436 | } |
| 437 | |
| 438 | if (buf[PAYLOAD_HEADER] != FRAME_START) { |
| 439 | dev_err(&client->dev, "invalid frame start: %d\n", buf[0]); |
| 440 | ret = -EIO; |
| 441 | goto unlock; |
| 442 | } |
| 443 | |
Luis Ortega | 5aee41a | 2014-01-27 12:27:49 -0800 | [diff] [blame] | 444 | if (buf[PAYLOAD_LENGTH] == 0) { |
Heiko Stübner | c6d81bd | 2013-10-31 01:25:32 -0700 | [diff] [blame] | 445 | dev_err(&client->dev, "invalid payload length: %d\n", |
| 446 | buf[PAYLOAD_LENGTH]); |
| 447 | ret = -EIO; |
| 448 | goto unlock; |
| 449 | } |
| 450 | |
| 451 | /* read the message */ |
| 452 | ret = i2c_master_recv(client, &buf[PAYLOAD_BODY], buf[PAYLOAD_LENGTH]); |
| 453 | if (ret < 0) { |
| 454 | dev_err(&client->dev, "error reading payload: %d\n", ret); |
| 455 | goto unlock; |
| 456 | } |
| 457 | |
| 458 | dev_dbg(&client->dev, "read %d bytes for response command 0x%x\n", |
| 459 | buf[PAYLOAD_LENGTH], buf[PAYLOAD_BODY]); |
| 460 | |
| 461 | unlock: |
| 462 | mutex_unlock(&ts->access_mutex); |
| 463 | return ret; |
| 464 | } |
| 465 | |
| 466 | static void zforce_complete(struct zforce_ts *ts, int cmd, int result) |
| 467 | { |
| 468 | struct i2c_client *client = ts->client; |
| 469 | |
| 470 | if (ts->command_waiting == cmd) { |
| 471 | dev_dbg(&client->dev, "completing command 0x%x\n", cmd); |
| 472 | ts->command_result = result; |
| 473 | complete(&ts->command_done); |
| 474 | } else { |
| 475 | dev_dbg(&client->dev, "command %d not for us\n", cmd); |
| 476 | } |
| 477 | } |
| 478 | |
Heiko Stübner | 499e612 | 2013-12-14 01:41:55 -0800 | [diff] [blame] | 479 | static irqreturn_t zforce_irq(int irq, void *dev_id) |
| 480 | { |
| 481 | struct zforce_ts *ts = dev_id; |
| 482 | struct i2c_client *client = ts->client; |
| 483 | |
| 484 | if (ts->suspended && device_may_wakeup(&client->dev)) |
| 485 | pm_wakeup_event(&client->dev, 500); |
| 486 | |
| 487 | return IRQ_WAKE_THREAD; |
| 488 | } |
| 489 | |
| 490 | static irqreturn_t zforce_irq_thread(int irq, void *dev_id) |
Heiko Stübner | c6d81bd | 2013-10-31 01:25:32 -0700 | [diff] [blame] | 491 | { |
| 492 | struct zforce_ts *ts = dev_id; |
| 493 | struct i2c_client *client = ts->client; |
Heiko Stübner | c6d81bd | 2013-10-31 01:25:32 -0700 | [diff] [blame] | 494 | int ret; |
Luis Ortega | d333b60 | 2014-01-27 12:28:33 -0800 | [diff] [blame] | 495 | u8 payload_buffer[FRAME_MAXSIZE]; |
Heiko Stübner | c6d81bd | 2013-10-31 01:25:32 -0700 | [diff] [blame] | 496 | u8 *payload; |
| 497 | |
| 498 | /* |
Heiko Stübner | 499e612 | 2013-12-14 01:41:55 -0800 | [diff] [blame] | 499 | * When still suspended, return. |
Heiko Stübner | c6d81bd | 2013-10-31 01:25:32 -0700 | [diff] [blame] | 500 | * Due to the level-interrupt we will get re-triggered later. |
| 501 | */ |
| 502 | if (ts->suspended) { |
Heiko Stübner | c6d81bd | 2013-10-31 01:25:32 -0700 | [diff] [blame] | 503 | msleep(20); |
| 504 | return IRQ_HANDLED; |
| 505 | } |
| 506 | |
| 507 | dev_dbg(&client->dev, "handling interrupt\n"); |
| 508 | |
| 509 | /* Don't emit wakeup events from commands run by zforce_suspend */ |
| 510 | if (!ts->suspending && device_may_wakeup(&client->dev)) |
| 511 | pm_stay_awake(&client->dev); |
| 512 | |
Dirk Behme | 62f4666 | 2015-08-03 13:03:09 -0700 | [diff] [blame] | 513 | /* |
| 514 | * Run at least once and exit the loop if |
| 515 | * - the optional interrupt GPIO isn't specified |
| 516 | * (there is only one packet read per ISR invocation, then) |
| 517 | * or |
| 518 | * - the GPIO isn't active any more |
| 519 | * (packet read until the level GPIO indicates that there is |
| 520 | * no IRQ any more) |
| 521 | */ |
| 522 | do { |
Heiko Stübner | c6d81bd | 2013-10-31 01:25:32 -0700 | [diff] [blame] | 523 | ret = zforce_read_packet(ts, payload_buffer); |
| 524 | if (ret < 0) { |
Luis Ortega | ad697b9 | 2014-01-27 12:27:35 -0800 | [diff] [blame] | 525 | dev_err(&client->dev, |
| 526 | "could not read packet, ret: %d\n", ret); |
Heiko Stübner | c6d81bd | 2013-10-31 01:25:32 -0700 | [diff] [blame] | 527 | break; |
| 528 | } |
| 529 | |
| 530 | payload = &payload_buffer[PAYLOAD_BODY]; |
| 531 | |
| 532 | switch (payload[RESPONSE_ID]) { |
| 533 | case NOTIFICATION_TOUCH: |
| 534 | /* |
| 535 | * Always report touch-events received while |
| 536 | * suspending, when being a wakeup source |
| 537 | */ |
| 538 | if (ts->suspending && device_may_wakeup(&client->dev)) |
| 539 | pm_wakeup_event(&client->dev, 500); |
| 540 | zforce_touch_event(ts, &payload[RESPONSE_DATA]); |
| 541 | break; |
| 542 | |
| 543 | case NOTIFICATION_BOOTCOMPLETE: |
| 544 | ts->boot_complete = payload[RESPONSE_DATA]; |
| 545 | zforce_complete(ts, payload[RESPONSE_ID], 0); |
| 546 | break; |
| 547 | |
| 548 | case RESPONSE_INITIALIZE: |
| 549 | case RESPONSE_DEACTIVATE: |
| 550 | case RESPONSE_SETCONFIG: |
| 551 | case RESPONSE_RESOLUTION: |
| 552 | case RESPONSE_SCANFREQ: |
| 553 | zforce_complete(ts, payload[RESPONSE_ID], |
| 554 | payload[RESPONSE_DATA]); |
| 555 | break; |
| 556 | |
| 557 | case RESPONSE_STATUS: |
| 558 | /* |
| 559 | * Version Payload Results |
| 560 | * [2:major] [2:minor] [2:build] [2:rev] |
| 561 | */ |
| 562 | ts->version_major = (payload[RESPONSE_DATA + 1] << 8) | |
| 563 | payload[RESPONSE_DATA]; |
| 564 | ts->version_minor = (payload[RESPONSE_DATA + 3] << 8) | |
| 565 | payload[RESPONSE_DATA + 2]; |
| 566 | ts->version_build = (payload[RESPONSE_DATA + 5] << 8) | |
| 567 | payload[RESPONSE_DATA + 4]; |
| 568 | ts->version_rev = (payload[RESPONSE_DATA + 7] << 8) | |
| 569 | payload[RESPONSE_DATA + 6]; |
Luis Ortega | ad697b9 | 2014-01-27 12:27:35 -0800 | [diff] [blame] | 570 | dev_dbg(&ts->client->dev, |
| 571 | "Firmware Version %04x:%04x %04x:%04x\n", |
Heiko Stübner | c6d81bd | 2013-10-31 01:25:32 -0700 | [diff] [blame] | 572 | ts->version_major, ts->version_minor, |
| 573 | ts->version_build, ts->version_rev); |
| 574 | |
| 575 | zforce_complete(ts, payload[RESPONSE_ID], 0); |
| 576 | break; |
| 577 | |
| 578 | case NOTIFICATION_INVALID_COMMAND: |
| 579 | dev_err(&ts->client->dev, "invalid command: 0x%x\n", |
| 580 | payload[RESPONSE_DATA]); |
| 581 | break; |
| 582 | |
| 583 | default: |
Luis Ortega | ad697b9 | 2014-01-27 12:27:35 -0800 | [diff] [blame] | 584 | dev_err(&ts->client->dev, |
| 585 | "unrecognized response id: 0x%x\n", |
Heiko Stübner | c6d81bd | 2013-10-31 01:25:32 -0700 | [diff] [blame] | 586 | payload[RESPONSE_ID]); |
| 587 | break; |
| 588 | } |
Dirk Behme | 62f4666 | 2015-08-03 13:03:09 -0700 | [diff] [blame] | 589 | } while (gpiod_get_value_cansleep(ts->gpio_int)); |
Heiko Stübner | c6d81bd | 2013-10-31 01:25:32 -0700 | [diff] [blame] | 590 | |
| 591 | if (!ts->suspending && device_may_wakeup(&client->dev)) |
| 592 | pm_relax(&client->dev); |
| 593 | |
| 594 | dev_dbg(&client->dev, "finished interrupt\n"); |
| 595 | |
| 596 | return IRQ_HANDLED; |
| 597 | } |
| 598 | |
| 599 | static int zforce_input_open(struct input_dev *dev) |
| 600 | { |
| 601 | struct zforce_ts *ts = input_get_drvdata(dev); |
Heiko Stübner | c6d81bd | 2013-10-31 01:25:32 -0700 | [diff] [blame] | 602 | |
Javier Martinez Canillas | a47fcbc | 2015-10-02 11:15:08 -0700 | [diff] [blame] | 603 | return zforce_start(ts); |
Heiko Stübner | c6d81bd | 2013-10-31 01:25:32 -0700 | [diff] [blame] | 604 | } |
| 605 | |
| 606 | static void zforce_input_close(struct input_dev *dev) |
| 607 | { |
| 608 | struct zforce_ts *ts = input_get_drvdata(dev); |
| 609 | struct i2c_client *client = ts->client; |
| 610 | int ret; |
| 611 | |
| 612 | ret = zforce_stop(ts); |
| 613 | if (ret) |
| 614 | dev_warn(&client->dev, "stopping zforce failed\n"); |
| 615 | |
| 616 | return; |
| 617 | } |
| 618 | |
Jingoo Han | 02b6a58 | 2014-11-02 00:04:14 -0700 | [diff] [blame] | 619 | static int __maybe_unused zforce_suspend(struct device *dev) |
Heiko Stübner | c6d81bd | 2013-10-31 01:25:32 -0700 | [diff] [blame] | 620 | { |
| 621 | struct i2c_client *client = to_i2c_client(dev); |
| 622 | struct zforce_ts *ts = i2c_get_clientdata(client); |
| 623 | struct input_dev *input = ts->input; |
| 624 | int ret = 0; |
| 625 | |
| 626 | mutex_lock(&input->mutex); |
| 627 | ts->suspending = true; |
| 628 | |
| 629 | /* |
| 630 | * When configured as a wakeup source device should always wake |
| 631 | * the system, therefore start device if necessary. |
| 632 | */ |
| 633 | if (device_may_wakeup(&client->dev)) { |
| 634 | dev_dbg(&client->dev, "suspend while being a wakeup source\n"); |
| 635 | |
| 636 | /* Need to start device, if not open, to be a wakeup source. */ |
| 637 | if (!input->users) { |
| 638 | ret = zforce_start(ts); |
| 639 | if (ret) |
| 640 | goto unlock; |
| 641 | } |
| 642 | |
| 643 | enable_irq_wake(client->irq); |
| 644 | } else if (input->users) { |
Luis Ortega | ad697b9 | 2014-01-27 12:27:35 -0800 | [diff] [blame] | 645 | dev_dbg(&client->dev, |
| 646 | "suspend without being a wakeup source\n"); |
Heiko Stübner | c6d81bd | 2013-10-31 01:25:32 -0700 | [diff] [blame] | 647 | |
| 648 | ret = zforce_stop(ts); |
| 649 | if (ret) |
| 650 | goto unlock; |
| 651 | |
| 652 | disable_irq(client->irq); |
| 653 | } |
| 654 | |
| 655 | ts->suspended = true; |
| 656 | |
| 657 | unlock: |
| 658 | ts->suspending = false; |
| 659 | mutex_unlock(&input->mutex); |
| 660 | |
| 661 | return ret; |
| 662 | } |
| 663 | |
Jingoo Han | 02b6a58 | 2014-11-02 00:04:14 -0700 | [diff] [blame] | 664 | static int __maybe_unused zforce_resume(struct device *dev) |
Heiko Stübner | c6d81bd | 2013-10-31 01:25:32 -0700 | [diff] [blame] | 665 | { |
| 666 | struct i2c_client *client = to_i2c_client(dev); |
| 667 | struct zforce_ts *ts = i2c_get_clientdata(client); |
| 668 | struct input_dev *input = ts->input; |
| 669 | int ret = 0; |
| 670 | |
| 671 | mutex_lock(&input->mutex); |
| 672 | |
| 673 | ts->suspended = false; |
| 674 | |
| 675 | if (device_may_wakeup(&client->dev)) { |
| 676 | dev_dbg(&client->dev, "resume from being a wakeup source\n"); |
| 677 | |
| 678 | disable_irq_wake(client->irq); |
| 679 | |
| 680 | /* need to stop device if it was not open on suspend */ |
| 681 | if (!input->users) { |
| 682 | ret = zforce_stop(ts); |
| 683 | if (ret) |
| 684 | goto unlock; |
| 685 | } |
| 686 | } else if (input->users) { |
| 687 | dev_dbg(&client->dev, "resume without being a wakeup source\n"); |
| 688 | |
| 689 | enable_irq(client->irq); |
| 690 | |
| 691 | ret = zforce_start(ts); |
| 692 | if (ret < 0) |
| 693 | goto unlock; |
| 694 | } |
| 695 | |
| 696 | unlock: |
| 697 | mutex_unlock(&input->mutex); |
| 698 | |
| 699 | return ret; |
| 700 | } |
Heiko Stübner | c6d81bd | 2013-10-31 01:25:32 -0700 | [diff] [blame] | 701 | |
| 702 | static SIMPLE_DEV_PM_OPS(zforce_pm_ops, zforce_suspend, zforce_resume); |
| 703 | |
| 704 | static void zforce_reset(void *data) |
| 705 | { |
| 706 | struct zforce_ts *ts = data; |
| 707 | |
Dirk Behme | 2d53809 | 2015-07-06 15:57:44 -0700 | [diff] [blame] | 708 | zforce_reset_assert(ts); |
Heiko Stuebner | 3974037 | 2014-07-21 10:02:11 -0700 | [diff] [blame] | 709 | |
| 710 | udelay(10); |
| 711 | |
| 712 | if (!IS_ERR(ts->reg_vdd)) |
| 713 | regulator_disable(ts->reg_vdd); |
Heiko Stübner | c6d81bd | 2013-10-31 01:25:32 -0700 | [diff] [blame] | 714 | } |
| 715 | |
Heiko Stübner | 6f2e6c9 | 2014-01-27 12:37:21 -0800 | [diff] [blame] | 716 | static struct zforce_ts_platdata *zforce_parse_dt(struct device *dev) |
| 717 | { |
| 718 | struct zforce_ts_platdata *pdata; |
| 719 | struct device_node *np = dev->of_node; |
| 720 | |
| 721 | if (!np) |
| 722 | return ERR_PTR(-ENOENT); |
| 723 | |
| 724 | pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL); |
| 725 | if (!pdata) { |
| 726 | dev_err(dev, "failed to allocate platform data\n"); |
| 727 | return ERR_PTR(-ENOMEM); |
| 728 | } |
| 729 | |
Heiko Stübner | 6f2e6c9 | 2014-01-27 12:37:21 -0800 | [diff] [blame] | 730 | if (of_property_read_u32(np, "x-size", &pdata->x_max)) { |
| 731 | dev_err(dev, "failed to get x-size property\n"); |
| 732 | return ERR_PTR(-EINVAL); |
| 733 | } |
| 734 | |
| 735 | if (of_property_read_u32(np, "y-size", &pdata->y_max)) { |
| 736 | dev_err(dev, "failed to get y-size property\n"); |
| 737 | return ERR_PTR(-EINVAL); |
| 738 | } |
| 739 | |
| 740 | return pdata; |
| 741 | } |
| 742 | |
Heiko Stübner | c6d81bd | 2013-10-31 01:25:32 -0700 | [diff] [blame] | 743 | static int zforce_probe(struct i2c_client *client, |
| 744 | const struct i2c_device_id *id) |
| 745 | { |
| 746 | const struct zforce_ts_platdata *pdata = dev_get_platdata(&client->dev); |
| 747 | struct zforce_ts *ts; |
| 748 | struct input_dev *input_dev; |
| 749 | int ret; |
| 750 | |
Heiko Stübner | 6f2e6c9 | 2014-01-27 12:37:21 -0800 | [diff] [blame] | 751 | if (!pdata) { |
| 752 | pdata = zforce_parse_dt(&client->dev); |
| 753 | if (IS_ERR(pdata)) |
| 754 | return PTR_ERR(pdata); |
| 755 | } |
Heiko Stübner | c6d81bd | 2013-10-31 01:25:32 -0700 | [diff] [blame] | 756 | |
| 757 | ts = devm_kzalloc(&client->dev, sizeof(struct zforce_ts), GFP_KERNEL); |
| 758 | if (!ts) |
| 759 | return -ENOMEM; |
| 760 | |
Dirk Behme | 62f4666 | 2015-08-03 13:03:09 -0700 | [diff] [blame] | 761 | ts->gpio_rst = devm_gpiod_get_optional(&client->dev, "reset", |
| 762 | GPIOD_OUT_HIGH); |
Dirk Behme | 2d53809 | 2015-07-06 15:57:44 -0700 | [diff] [blame] | 763 | if (IS_ERR(ts->gpio_rst)) { |
| 764 | ret = PTR_ERR(ts->gpio_rst); |
| 765 | dev_err(&client->dev, |
| 766 | "failed to request reset GPIO: %d\n", ret); |
Heiko Stübner | c6d81bd | 2013-10-31 01:25:32 -0700 | [diff] [blame] | 767 | return ret; |
| 768 | } |
| 769 | |
Dirk Behme | 62f4666 | 2015-08-03 13:03:09 -0700 | [diff] [blame] | 770 | if (ts->gpio_rst) { |
| 771 | ts->gpio_int = devm_gpiod_get_optional(&client->dev, "irq", |
| 772 | GPIOD_IN); |
| 773 | if (IS_ERR(ts->gpio_int)) { |
| 774 | ret = PTR_ERR(ts->gpio_int); |
| 775 | dev_err(&client->dev, |
| 776 | "failed to request interrupt GPIO: %d\n", ret); |
| 777 | return ret; |
| 778 | } |
| 779 | } else { |
| 780 | /* |
| 781 | * Deprecated GPIO handling for compatibility |
| 782 | * with legacy binding. |
| 783 | */ |
| 784 | |
| 785 | /* INT GPIO */ |
| 786 | ts->gpio_int = devm_gpiod_get_index(&client->dev, NULL, 0, |
| 787 | GPIOD_IN); |
| 788 | if (IS_ERR(ts->gpio_int)) { |
| 789 | ret = PTR_ERR(ts->gpio_int); |
| 790 | dev_err(&client->dev, |
| 791 | "failed to request interrupt GPIO: %d\n", ret); |
| 792 | return ret; |
| 793 | } |
| 794 | |
| 795 | /* RST GPIO */ |
| 796 | ts->gpio_rst = devm_gpiod_get_index(&client->dev, NULL, 1, |
| 797 | GPIOD_OUT_HIGH); |
| 798 | if (IS_ERR(ts->gpio_rst)) { |
| 799 | ret = PTR_ERR(ts->gpio_rst); |
| 800 | dev_err(&client->dev, |
| 801 | "failed to request reset GPIO: %d\n", ret); |
| 802 | return ret; |
| 803 | } |
| 804 | } |
| 805 | |
Heiko Stuebner | 3974037 | 2014-07-21 10:02:11 -0700 | [diff] [blame] | 806 | ts->reg_vdd = devm_regulator_get_optional(&client->dev, "vdd"); |
| 807 | if (IS_ERR(ts->reg_vdd)) { |
| 808 | ret = PTR_ERR(ts->reg_vdd); |
| 809 | if (ret == -EPROBE_DEFER) |
| 810 | return ret; |
| 811 | } else { |
| 812 | ret = regulator_enable(ts->reg_vdd); |
| 813 | if (ret) |
| 814 | return ret; |
| 815 | |
| 816 | /* |
| 817 | * according to datasheet add 100us grace time after regular |
| 818 | * regulator enable delay. |
| 819 | */ |
| 820 | udelay(100); |
| 821 | } |
| 822 | |
Heiko Stübner | c6d81bd | 2013-10-31 01:25:32 -0700 | [diff] [blame] | 823 | ret = devm_add_action(&client->dev, zforce_reset, ts); |
| 824 | if (ret) { |
| 825 | dev_err(&client->dev, "failed to register reset action, %d\n", |
| 826 | ret); |
Heiko Stuebner | 3974037 | 2014-07-21 10:02:11 -0700 | [diff] [blame] | 827 | |
| 828 | /* hereafter the regulator will be disabled by the action */ |
| 829 | if (!IS_ERR(ts->reg_vdd)) |
| 830 | regulator_disable(ts->reg_vdd); |
| 831 | |
Heiko Stübner | c6d81bd | 2013-10-31 01:25:32 -0700 | [diff] [blame] | 832 | return ret; |
| 833 | } |
| 834 | |
| 835 | snprintf(ts->phys, sizeof(ts->phys), |
| 836 | "%s/input0", dev_name(&client->dev)); |
| 837 | |
| 838 | input_dev = devm_input_allocate_device(&client->dev); |
| 839 | if (!input_dev) { |
| 840 | dev_err(&client->dev, "could not allocate input device\n"); |
| 841 | return -ENOMEM; |
| 842 | } |
| 843 | |
| 844 | mutex_init(&ts->access_mutex); |
| 845 | mutex_init(&ts->command_mutex); |
| 846 | |
| 847 | ts->pdata = pdata; |
| 848 | ts->client = client; |
| 849 | ts->input = input_dev; |
| 850 | |
| 851 | input_dev->name = "Neonode zForce touchscreen"; |
| 852 | input_dev->phys = ts->phys; |
| 853 | input_dev->id.bustype = BUS_I2C; |
| 854 | |
| 855 | input_dev->open = zforce_input_open; |
| 856 | input_dev->close = zforce_input_close; |
| 857 | |
| 858 | __set_bit(EV_KEY, input_dev->evbit); |
| 859 | __set_bit(EV_SYN, input_dev->evbit); |
| 860 | __set_bit(EV_ABS, input_dev->evbit); |
| 861 | |
| 862 | /* For multi touch */ |
| 863 | input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0, |
| 864 | pdata->x_max, 0, 0); |
| 865 | input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0, |
| 866 | pdata->y_max, 0, 0); |
| 867 | |
| 868 | input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, |
| 869 | ZFORCE_MAX_AREA, 0, 0); |
| 870 | input_set_abs_params(input_dev, ABS_MT_TOUCH_MINOR, 0, |
| 871 | ZFORCE_MAX_AREA, 0, 0); |
| 872 | input_set_abs_params(input_dev, ABS_MT_ORIENTATION, 0, 1, 0, 0); |
| 873 | input_mt_init_slots(input_dev, ZFORCE_REPORT_POINTS, INPUT_MT_DIRECT); |
| 874 | |
| 875 | input_set_drvdata(ts->input, ts); |
| 876 | |
| 877 | init_completion(&ts->command_done); |
| 878 | |
| 879 | /* |
| 880 | * The zforce pulls the interrupt low when it has data ready. |
| 881 | * After it is triggered the isr thread runs until all the available |
| 882 | * packets have been read and the interrupt is high again. |
| 883 | * Therefore we can trigger the interrupt anytime it is low and do |
| 884 | * not need to limit it to the interrupt edge. |
| 885 | */ |
Heiko Stübner | 499e612 | 2013-12-14 01:41:55 -0800 | [diff] [blame] | 886 | ret = devm_request_threaded_irq(&client->dev, client->irq, |
| 887 | zforce_irq, zforce_irq_thread, |
Heiko Stübner | c6d81bd | 2013-10-31 01:25:32 -0700 | [diff] [blame] | 888 | IRQF_TRIGGER_LOW | IRQF_ONESHOT, |
| 889 | input_dev->name, ts); |
| 890 | if (ret) { |
| 891 | dev_err(&client->dev, "irq %d request failed\n", client->irq); |
| 892 | return ret; |
| 893 | } |
| 894 | |
| 895 | i2c_set_clientdata(client, ts); |
| 896 | |
| 897 | /* let the controller boot */ |
Dirk Behme | 2d53809 | 2015-07-06 15:57:44 -0700 | [diff] [blame] | 898 | zforce_reset_deassert(ts); |
Heiko Stübner | c6d81bd | 2013-10-31 01:25:32 -0700 | [diff] [blame] | 899 | |
| 900 | ts->command_waiting = NOTIFICATION_BOOTCOMPLETE; |
| 901 | if (wait_for_completion_timeout(&ts->command_done, WAIT_TIMEOUT) == 0) |
| 902 | dev_warn(&client->dev, "bootcomplete timed out\n"); |
| 903 | |
| 904 | /* need to start device to get version information */ |
| 905 | ret = zforce_command_wait(ts, COMMAND_INITIALIZE); |
| 906 | if (ret) { |
| 907 | dev_err(&client->dev, "unable to initialize, %d\n", ret); |
| 908 | return ret; |
| 909 | } |
| 910 | |
Luis Ortega | deb4981 | 2014-01-27 12:27:06 -0800 | [diff] [blame] | 911 | /* this gets the firmware version among other information */ |
Heiko Stübner | c6d81bd | 2013-10-31 01:25:32 -0700 | [diff] [blame] | 912 | ret = zforce_command_wait(ts, COMMAND_STATUS); |
| 913 | if (ret < 0) { |
| 914 | dev_err(&client->dev, "couldn't get status, %d\n", ret); |
| 915 | zforce_stop(ts); |
| 916 | return ret; |
| 917 | } |
| 918 | |
| 919 | /* stop device and put it into sleep until it is opened */ |
| 920 | ret = zforce_stop(ts); |
| 921 | if (ret < 0) |
| 922 | return ret; |
| 923 | |
| 924 | device_set_wakeup_capable(&client->dev, true); |
| 925 | |
| 926 | ret = input_register_device(input_dev); |
| 927 | if (ret) { |
| 928 | dev_err(&client->dev, "could not register input device, %d\n", |
| 929 | ret); |
| 930 | return ret; |
| 931 | } |
| 932 | |
| 933 | return 0; |
| 934 | } |
| 935 | |
| 936 | static struct i2c_device_id zforce_idtable[] = { |
| 937 | { "zforce-ts", 0 }, |
| 938 | { } |
| 939 | }; |
| 940 | MODULE_DEVICE_TABLE(i2c, zforce_idtable); |
| 941 | |
Heiko Stübner | 6f2e6c9 | 2014-01-27 12:37:21 -0800 | [diff] [blame] | 942 | #ifdef CONFIG_OF |
Jingoo Han | f3f6319 | 2014-05-07 13:10:16 -0700 | [diff] [blame] | 943 | static const struct of_device_id zforce_dt_idtable[] = { |
Heiko Stübner | 6f2e6c9 | 2014-01-27 12:37:21 -0800 | [diff] [blame] | 944 | { .compatible = "neonode,zforce" }, |
| 945 | {}, |
| 946 | }; |
| 947 | MODULE_DEVICE_TABLE(of, zforce_dt_idtable); |
| 948 | #endif |
| 949 | |
Heiko Stübner | c6d81bd | 2013-10-31 01:25:32 -0700 | [diff] [blame] | 950 | static struct i2c_driver zforce_driver = { |
| 951 | .driver = { |
Heiko Stübner | c6d81bd | 2013-10-31 01:25:32 -0700 | [diff] [blame] | 952 | .name = "zforce-ts", |
| 953 | .pm = &zforce_pm_ops, |
Heiko Stübner | 6f2e6c9 | 2014-01-27 12:37:21 -0800 | [diff] [blame] | 954 | .of_match_table = of_match_ptr(zforce_dt_idtable), |
Heiko Stübner | c6d81bd | 2013-10-31 01:25:32 -0700 | [diff] [blame] | 955 | }, |
| 956 | .probe = zforce_probe, |
| 957 | .id_table = zforce_idtable, |
| 958 | }; |
| 959 | |
| 960 | module_i2c_driver(zforce_driver); |
| 961 | |
| 962 | MODULE_AUTHOR("Heiko Stuebner <heiko@sntech.de>"); |
| 963 | MODULE_DESCRIPTION("zForce TouchScreen Driver"); |
| 964 | MODULE_LICENSE("GPL"); |