elan_i2c_i2c.c 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Elan I2C/SMBus Touchpad driver - I2C interface
  4. *
  5. * Copyright (c) 2013 ELAN Microelectronics Corp.
  6. *
  7. * Author: 林政維 (Duson Lin) <dusonlin@emc.com.tw>
  8. *
  9. * Based on cyapa driver:
  10. * copyright (c) 2011-2012 Cypress Semiconductor, Inc.
  11. * copyright (c) 2011-2012 Google, Inc.
  12. *
  13. * Trademarks are the property of their respective owners.
  14. */
  15. #include <linux/completion.h>
  16. #include <linux/delay.h>
  17. #include <linux/i2c.h>
  18. #include <linux/interrupt.h>
  19. #include <linux/jiffies.h>
  20. #include <linux/kernel.h>
  21. #include <linux/slab.h>
  22. #include <linux/sched.h>
  23. #include <asm/unaligned.h>
  24. #include "elan_i2c.h"
  25. /* Elan i2c commands */
  26. #define ETP_I2C_RESET 0x0100
  27. #define ETP_I2C_WAKE_UP 0x0800
  28. #define ETP_I2C_SLEEP 0x0801
  29. #define ETP_I2C_DESC_CMD 0x0001
  30. #define ETP_I2C_REPORT_DESC_CMD 0x0002
  31. #define ETP_I2C_STAND_CMD 0x0005
  32. #define ETP_I2C_PATTERN_CMD 0x0100
  33. #define ETP_I2C_UNIQUEID_CMD 0x0101
  34. #define ETP_I2C_FW_VERSION_CMD 0x0102
  35. #define ETP_I2C_IC_TYPE_CMD 0x0103
  36. #define ETP_I2C_OSM_VERSION_CMD 0x0103
  37. #define ETP_I2C_NSM_VERSION_CMD 0x0104
  38. #define ETP_I2C_XY_TRACENUM_CMD 0x0105
  39. #define ETP_I2C_MAX_X_AXIS_CMD 0x0106
  40. #define ETP_I2C_MAX_Y_AXIS_CMD 0x0107
  41. #define ETP_I2C_RESOLUTION_CMD 0x0108
  42. #define ETP_I2C_PRESSURE_CMD 0x010A
  43. #define ETP_I2C_IAP_VERSION_CMD 0x0110
  44. #define ETP_I2C_IC_TYPE_P0_CMD 0x0110
  45. #define ETP_I2C_IAP_VERSION_P0_CMD 0x0111
  46. #define ETP_I2C_SET_CMD 0x0300
  47. #define ETP_I2C_POWER_CMD 0x0307
  48. #define ETP_I2C_FW_CHECKSUM_CMD 0x030F
  49. #define ETP_I2C_IAP_CTRL_CMD 0x0310
  50. #define ETP_I2C_IAP_CMD 0x0311
  51. #define ETP_I2C_IAP_RESET_CMD 0x0314
  52. #define ETP_I2C_IAP_CHECKSUM_CMD 0x0315
  53. #define ETP_I2C_CALIBRATE_CMD 0x0316
  54. #define ETP_I2C_MAX_BASELINE_CMD 0x0317
  55. #define ETP_I2C_MIN_BASELINE_CMD 0x0318
  56. #define ETP_I2C_IAP_TYPE_REG 0x0040
  57. #define ETP_I2C_IAP_TYPE_CMD 0x0304
  58. #define ETP_I2C_REPORT_LEN 34
  59. #define ETP_I2C_REPORT_LEN_ID2 39
  60. #define ETP_I2C_REPORT_MAX_LEN 39
  61. #define ETP_I2C_DESC_LENGTH 30
  62. #define ETP_I2C_REPORT_DESC_LENGTH 158
  63. #define ETP_I2C_INF_LENGTH 2
  64. #define ETP_I2C_IAP_PASSWORD 0x1EA5
  65. #define ETP_I2C_IAP_RESET 0xF0F0
  66. #define ETP_I2C_MAIN_MODE_ON (1 << 9)
  67. #define ETP_I2C_IAP_REG_L 0x01
  68. #define ETP_I2C_IAP_REG_H 0x06
  69. static int elan_i2c_read_block(struct i2c_client *client,
  70. u16 reg, u8 *val, u16 len)
  71. {
  72. __le16 buf[] = {
  73. cpu_to_le16(reg),
  74. };
  75. struct i2c_msg msgs[] = {
  76. {
  77. .addr = client->addr,
  78. .flags = client->flags & I2C_M_TEN,
  79. .len = sizeof(buf),
  80. .buf = (u8 *)buf,
  81. },
  82. {
  83. .addr = client->addr,
  84. .flags = (client->flags & I2C_M_TEN) | I2C_M_RD,
  85. .len = len,
  86. .buf = val,
  87. }
  88. };
  89. int ret;
  90. ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
  91. return ret == ARRAY_SIZE(msgs) ? 0 : (ret < 0 ? ret : -EIO);
  92. }
  93. static int elan_i2c_read_cmd(struct i2c_client *client, u16 reg, u8 *val)
  94. {
  95. int retval;
  96. retval = elan_i2c_read_block(client, reg, val, ETP_I2C_INF_LENGTH);
  97. if (retval < 0) {
  98. dev_err(&client->dev, "reading cmd (0x%04x) fail.\n", reg);
  99. return retval;
  100. }
  101. return 0;
  102. }
  103. static int elan_i2c_write_cmd(struct i2c_client *client, u16 reg, u16 cmd)
  104. {
  105. __le16 buf[] = {
  106. cpu_to_le16(reg),
  107. cpu_to_le16(cmd),
  108. };
  109. struct i2c_msg msg = {
  110. .addr = client->addr,
  111. .flags = client->flags & I2C_M_TEN,
  112. .len = sizeof(buf),
  113. .buf = (u8 *)buf,
  114. };
  115. int ret;
  116. ret = i2c_transfer(client->adapter, &msg, 1);
  117. if (ret != 1) {
  118. if (ret >= 0)
  119. ret = -EIO;
  120. dev_err(&client->dev, "writing cmd (0x%04x) failed: %d\n",
  121. reg, ret);
  122. return ret;
  123. }
  124. return 0;
  125. }
  126. static int elan_i2c_initialize(struct i2c_client *client)
  127. {
  128. struct device *dev = &client->dev;
  129. int error;
  130. u8 val[256];
  131. error = elan_i2c_write_cmd(client, ETP_I2C_STAND_CMD, ETP_I2C_RESET);
  132. if (error) {
  133. dev_err(dev, "device reset failed: %d\n", error);
  134. return error;
  135. }
  136. /* Wait for the device to reset */
  137. msleep(100);
  138. /* get reset acknowledgement 0000 */
  139. error = i2c_master_recv(client, val, ETP_I2C_INF_LENGTH);
  140. if (error < 0) {
  141. dev_err(dev, "failed to read reset response: %d\n", error);
  142. return error;
  143. }
  144. error = elan_i2c_read_block(client, ETP_I2C_DESC_CMD,
  145. val, ETP_I2C_DESC_LENGTH);
  146. if (error) {
  147. dev_err(dev, "cannot get device descriptor: %d\n", error);
  148. return error;
  149. }
  150. error = elan_i2c_read_block(client, ETP_I2C_REPORT_DESC_CMD,
  151. val, ETP_I2C_REPORT_DESC_LENGTH);
  152. if (error) {
  153. dev_err(dev, "fetching report descriptor failed.: %d\n", error);
  154. return error;
  155. }
  156. return 0;
  157. }
  158. static int elan_i2c_sleep_control(struct i2c_client *client, bool sleep)
  159. {
  160. return elan_i2c_write_cmd(client, ETP_I2C_STAND_CMD,
  161. sleep ? ETP_I2C_SLEEP : ETP_I2C_WAKE_UP);
  162. }
  163. static int elan_i2c_power_control(struct i2c_client *client, bool enable)
  164. {
  165. u8 val[2];
  166. u16 reg;
  167. int error;
  168. error = elan_i2c_read_cmd(client, ETP_I2C_POWER_CMD, val);
  169. if (error) {
  170. dev_err(&client->dev,
  171. "failed to read current power state: %d\n",
  172. error);
  173. return error;
  174. }
  175. reg = le16_to_cpup((__le16 *)val);
  176. if (enable)
  177. reg &= ~ETP_DISABLE_POWER;
  178. else
  179. reg |= ETP_DISABLE_POWER;
  180. error = elan_i2c_write_cmd(client, ETP_I2C_POWER_CMD, reg);
  181. if (error) {
  182. dev_err(&client->dev,
  183. "failed to write current power state: %d\n",
  184. error);
  185. return error;
  186. }
  187. return 0;
  188. }
  189. static int elan_i2c_set_mode(struct i2c_client *client, u8 mode)
  190. {
  191. return elan_i2c_write_cmd(client, ETP_I2C_SET_CMD, mode);
  192. }
  193. static int elan_i2c_calibrate(struct i2c_client *client)
  194. {
  195. return elan_i2c_write_cmd(client, ETP_I2C_CALIBRATE_CMD, 1);
  196. }
  197. static int elan_i2c_calibrate_result(struct i2c_client *client, u8 *val)
  198. {
  199. return elan_i2c_read_block(client, ETP_I2C_CALIBRATE_CMD, val, 1);
  200. }
  201. static int elan_i2c_get_baseline_data(struct i2c_client *client,
  202. bool max_baseline, u8 *value)
  203. {
  204. int error;
  205. u8 val[3];
  206. error = elan_i2c_read_cmd(client,
  207. max_baseline ? ETP_I2C_MAX_BASELINE_CMD :
  208. ETP_I2C_MIN_BASELINE_CMD,
  209. val);
  210. if (error)
  211. return error;
  212. *value = le16_to_cpup((__le16 *)val);
  213. return 0;
  214. }
  215. static int elan_i2c_get_pattern(struct i2c_client *client, u8 *pattern)
  216. {
  217. int error;
  218. u8 val[3];
  219. error = elan_i2c_read_cmd(client, ETP_I2C_PATTERN_CMD, val);
  220. if (error) {
  221. dev_err(&client->dev, "failed to get pattern: %d\n", error);
  222. return error;
  223. }
  224. /*
  225. * Not all versions of firmware implement "get pattern" command.
  226. * When this command is not implemented the device will respond
  227. * with 0xFF 0xFF, which we will treat as "old" pattern 0.
  228. */
  229. *pattern = val[0] == 0xFF && val[1] == 0xFF ? 0 : val[1];
  230. return 0;
  231. }
  232. static int elan_i2c_get_version(struct i2c_client *client,
  233. u8 pattern, bool iap, u8 *version)
  234. {
  235. int error;
  236. u16 cmd;
  237. u8 val[3];
  238. if (!iap)
  239. cmd = ETP_I2C_FW_VERSION_CMD;
  240. else if (pattern == 0)
  241. cmd = ETP_I2C_IAP_VERSION_P0_CMD;
  242. else
  243. cmd = ETP_I2C_IAP_VERSION_CMD;
  244. error = elan_i2c_read_cmd(client, cmd, val);
  245. if (error) {
  246. dev_err(&client->dev, "failed to get %s version: %d\n",
  247. iap ? "IAP" : "FW", error);
  248. return error;
  249. }
  250. if (pattern >= 0x01)
  251. *version = iap ? val[1] : val[0];
  252. else
  253. *version = val[0];
  254. return 0;
  255. }
  256. static int elan_i2c_get_sm_version(struct i2c_client *client, u8 pattern,
  257. u16 *ic_type, u8 *version, u8 *clickpad)
  258. {
  259. int error;
  260. u8 val[3];
  261. if (pattern >= 0x01) {
  262. error = elan_i2c_read_cmd(client, ETP_I2C_IC_TYPE_CMD, val);
  263. if (error) {
  264. dev_err(&client->dev, "failed to get ic type: %d\n",
  265. error);
  266. return error;
  267. }
  268. *ic_type = be16_to_cpup((__be16 *)val);
  269. error = elan_i2c_read_cmd(client, ETP_I2C_NSM_VERSION_CMD,
  270. val);
  271. if (error) {
  272. dev_err(&client->dev, "failed to get SM version: %d\n",
  273. error);
  274. return error;
  275. }
  276. *version = val[1];
  277. *clickpad = val[0] & 0x10;
  278. } else {
  279. error = elan_i2c_read_cmd(client, ETP_I2C_OSM_VERSION_CMD, val);
  280. if (error) {
  281. dev_err(&client->dev, "failed to get SM version: %d\n",
  282. error);
  283. return error;
  284. }
  285. *version = val[0];
  286. error = elan_i2c_read_cmd(client, ETP_I2C_IC_TYPE_P0_CMD, val);
  287. if (error) {
  288. dev_err(&client->dev, "failed to get ic type: %d\n",
  289. error);
  290. return error;
  291. }
  292. *ic_type = val[0];
  293. error = elan_i2c_read_cmd(client, ETP_I2C_NSM_VERSION_CMD,
  294. val);
  295. if (error) {
  296. dev_err(&client->dev, "failed to get SM version: %d\n",
  297. error);
  298. return error;
  299. }
  300. *clickpad = val[0] & 0x10;
  301. }
  302. return 0;
  303. }
  304. static int elan_i2c_get_product_id(struct i2c_client *client, u16 *id)
  305. {
  306. int error;
  307. u8 val[3];
  308. error = elan_i2c_read_cmd(client, ETP_I2C_UNIQUEID_CMD, val);
  309. if (error) {
  310. dev_err(&client->dev, "failed to get product ID: %d\n", error);
  311. return error;
  312. }
  313. *id = le16_to_cpup((__le16 *)val);
  314. return 0;
  315. }
  316. static int elan_i2c_get_checksum(struct i2c_client *client,
  317. bool iap, u16 *csum)
  318. {
  319. int error;
  320. u8 val[3];
  321. error = elan_i2c_read_cmd(client,
  322. iap ? ETP_I2C_IAP_CHECKSUM_CMD :
  323. ETP_I2C_FW_CHECKSUM_CMD,
  324. val);
  325. if (error) {
  326. dev_err(&client->dev, "failed to get %s checksum: %d\n",
  327. iap ? "IAP" : "FW", error);
  328. return error;
  329. }
  330. *csum = le16_to_cpup((__le16 *)val);
  331. return 0;
  332. }
  333. static int elan_i2c_get_max(struct i2c_client *client,
  334. unsigned int *max_x, unsigned int *max_y)
  335. {
  336. int error;
  337. u8 val[3];
  338. error = elan_i2c_read_cmd(client, ETP_I2C_MAX_X_AXIS_CMD, val);
  339. if (error) {
  340. dev_err(&client->dev, "failed to get X dimension: %d\n", error);
  341. return error;
  342. }
  343. *max_x = le16_to_cpup((__le16 *)val);
  344. error = elan_i2c_read_cmd(client, ETP_I2C_MAX_Y_AXIS_CMD, val);
  345. if (error) {
  346. dev_err(&client->dev, "failed to get Y dimension: %d\n", error);
  347. return error;
  348. }
  349. *max_y = le16_to_cpup((__le16 *)val);
  350. return 0;
  351. }
  352. static int elan_i2c_get_resolution(struct i2c_client *client,
  353. u8 *hw_res_x, u8 *hw_res_y)
  354. {
  355. int error;
  356. u8 val[3];
  357. error = elan_i2c_read_cmd(client, ETP_I2C_RESOLUTION_CMD, val);
  358. if (error) {
  359. dev_err(&client->dev, "failed to get resolution: %d\n", error);
  360. return error;
  361. }
  362. *hw_res_x = val[0];
  363. *hw_res_y = val[1];
  364. return 0;
  365. }
  366. static int elan_i2c_get_num_traces(struct i2c_client *client,
  367. unsigned int *x_traces,
  368. unsigned int *y_traces)
  369. {
  370. int error;
  371. u8 val[3];
  372. error = elan_i2c_read_cmd(client, ETP_I2C_XY_TRACENUM_CMD, val);
  373. if (error) {
  374. dev_err(&client->dev, "failed to get trace info: %d\n", error);
  375. return error;
  376. }
  377. *x_traces = val[0];
  378. *y_traces = val[1];
  379. return 0;
  380. }
  381. static int elan_i2c_get_pressure_adjustment(struct i2c_client *client,
  382. int *adjustment)
  383. {
  384. int error;
  385. u8 val[3];
  386. error = elan_i2c_read_cmd(client, ETP_I2C_PRESSURE_CMD, val);
  387. if (error) {
  388. dev_err(&client->dev, "failed to get pressure format: %d\n",
  389. error);
  390. return error;
  391. }
  392. if ((val[0] >> 4) & 0x1)
  393. *adjustment = 0;
  394. else
  395. *adjustment = ETP_PRESSURE_OFFSET;
  396. return 0;
  397. }
  398. static int elan_i2c_iap_get_mode(struct i2c_client *client, enum tp_mode *mode)
  399. {
  400. int error;
  401. u16 constant;
  402. u8 val[3];
  403. error = elan_i2c_read_cmd(client, ETP_I2C_IAP_CTRL_CMD, val);
  404. if (error) {
  405. dev_err(&client->dev,
  406. "failed to read iap control register: %d\n",
  407. error);
  408. return error;
  409. }
  410. constant = le16_to_cpup((__le16 *)val);
  411. dev_dbg(&client->dev, "iap control reg: 0x%04x.\n", constant);
  412. *mode = (constant & ETP_I2C_MAIN_MODE_ON) ? MAIN_MODE : IAP_MODE;
  413. return 0;
  414. }
  415. static int elan_i2c_iap_reset(struct i2c_client *client)
  416. {
  417. int error;
  418. error = elan_i2c_write_cmd(client, ETP_I2C_IAP_RESET_CMD,
  419. ETP_I2C_IAP_RESET);
  420. if (error) {
  421. dev_err(&client->dev, "cannot reset IC: %d\n", error);
  422. return error;
  423. }
  424. return 0;
  425. }
  426. static int elan_i2c_set_flash_key(struct i2c_client *client)
  427. {
  428. int error;
  429. error = elan_i2c_write_cmd(client, ETP_I2C_IAP_CMD,
  430. ETP_I2C_IAP_PASSWORD);
  431. if (error) {
  432. dev_err(&client->dev, "cannot set flash key: %d\n", error);
  433. return error;
  434. }
  435. return 0;
  436. }
  437. static int elan_read_write_iap_type(struct i2c_client *client, u16 fw_page_size)
  438. {
  439. int error;
  440. u16 constant;
  441. u8 val[3];
  442. int retry = 3;
  443. do {
  444. error = elan_i2c_write_cmd(client, ETP_I2C_IAP_TYPE_CMD,
  445. fw_page_size / 2);
  446. if (error) {
  447. dev_err(&client->dev,
  448. "cannot write iap type: %d\n", error);
  449. return error;
  450. }
  451. error = elan_i2c_read_cmd(client, ETP_I2C_IAP_TYPE_CMD, val);
  452. if (error) {
  453. dev_err(&client->dev,
  454. "failed to read iap type register: %d\n",
  455. error);
  456. return error;
  457. }
  458. constant = le16_to_cpup((__le16 *)val);
  459. dev_dbg(&client->dev, "iap type reg: 0x%04x\n", constant);
  460. if (constant == fw_page_size / 2)
  461. return 0;
  462. } while (--retry > 0);
  463. dev_err(&client->dev, "cannot set iap type\n");
  464. return -EIO;
  465. }
  466. static int elan_i2c_prepare_fw_update(struct i2c_client *client, u16 ic_type,
  467. u8 iap_version, u16 fw_page_size)
  468. {
  469. struct device *dev = &client->dev;
  470. int error;
  471. enum tp_mode mode;
  472. u8 val[3];
  473. u16 password;
  474. /* Get FW in which mode (IAP_MODE/MAIN_MODE) */
  475. error = elan_i2c_iap_get_mode(client, &mode);
  476. if (error)
  477. return error;
  478. if (mode == IAP_MODE) {
  479. /* Reset IC */
  480. error = elan_i2c_iap_reset(client);
  481. if (error)
  482. return error;
  483. msleep(30);
  484. }
  485. /* Set flash key*/
  486. error = elan_i2c_set_flash_key(client);
  487. if (error)
  488. return error;
  489. /* Wait for F/W IAP initialization */
  490. msleep(mode == MAIN_MODE ? 100 : 30);
  491. /* Check if we are in IAP mode or not */
  492. error = elan_i2c_iap_get_mode(client, &mode);
  493. if (error)
  494. return error;
  495. if (mode == MAIN_MODE) {
  496. dev_err(dev, "wrong mode: %d\n", mode);
  497. return -EIO;
  498. }
  499. if (ic_type >= 0x0D && iap_version >= 1) {
  500. error = elan_read_write_iap_type(client, fw_page_size);
  501. if (error)
  502. return error;
  503. }
  504. /* Set flash key again */
  505. error = elan_i2c_set_flash_key(client);
  506. if (error)
  507. return error;
  508. /* Wait for F/W IAP initialization */
  509. msleep(30);
  510. /* read back to check we actually enabled successfully. */
  511. error = elan_i2c_read_cmd(client, ETP_I2C_IAP_CMD, val);
  512. if (error) {
  513. dev_err(dev, "cannot read iap password: %d\n",
  514. error);
  515. return error;
  516. }
  517. password = le16_to_cpup((__le16 *)val);
  518. if (password != ETP_I2C_IAP_PASSWORD) {
  519. dev_err(dev, "wrong iap password: 0x%X\n", password);
  520. return -EIO;
  521. }
  522. return 0;
  523. }
  524. static int elan_i2c_write_fw_block(struct i2c_client *client, u16 fw_page_size,
  525. const u8 *page, u16 checksum, int idx)
  526. {
  527. struct device *dev = &client->dev;
  528. u8 *page_store;
  529. u8 val[3];
  530. u16 result;
  531. int ret, error;
  532. page_store = kmalloc(fw_page_size + 4, GFP_KERNEL);
  533. if (!page_store)
  534. return -ENOMEM;
  535. page_store[0] = ETP_I2C_IAP_REG_L;
  536. page_store[1] = ETP_I2C_IAP_REG_H;
  537. memcpy(&page_store[2], page, fw_page_size);
  538. /* recode checksum at last two bytes */
  539. put_unaligned_le16(checksum, &page_store[fw_page_size + 2]);
  540. ret = i2c_master_send(client, page_store, fw_page_size + 4);
  541. if (ret != fw_page_size + 4) {
  542. error = ret < 0 ? ret : -EIO;
  543. dev_err(dev, "Failed to write page %d: %d\n", idx, error);
  544. goto exit;
  545. }
  546. /* Wait for F/W to update one page ROM data. */
  547. msleep(fw_page_size == ETP_FW_PAGE_SIZE_512 ? 50 : 35);
  548. error = elan_i2c_read_cmd(client, ETP_I2C_IAP_CTRL_CMD, val);
  549. if (error) {
  550. dev_err(dev, "Failed to read IAP write result: %d\n", error);
  551. goto exit;
  552. }
  553. result = le16_to_cpup((__le16 *)val);
  554. if (result & (ETP_FW_IAP_PAGE_ERR | ETP_FW_IAP_INTF_ERR)) {
  555. dev_err(dev, "IAP reports failed write: %04hx\n",
  556. result);
  557. error = -EIO;
  558. goto exit;
  559. }
  560. exit:
  561. kfree(page_store);
  562. return error;
  563. }
  564. static int elan_i2c_finish_fw_update(struct i2c_client *client,
  565. struct completion *completion)
  566. {
  567. struct device *dev = &client->dev;
  568. int error = 0;
  569. int len;
  570. u8 buffer[ETP_I2C_REPORT_MAX_LEN];
  571. len = i2c_master_recv(client, buffer, ETP_I2C_REPORT_MAX_LEN);
  572. if (len <= 0) {
  573. error = len < 0 ? len : -EIO;
  574. dev_warn(dev, "failed to read I2C data after FW WDT reset: %d (%d)\n",
  575. error, len);
  576. }
  577. reinit_completion(completion);
  578. enable_irq(client->irq);
  579. error = elan_i2c_write_cmd(client, ETP_I2C_STAND_CMD, ETP_I2C_RESET);
  580. if (error) {
  581. dev_err(dev, "device reset failed: %d\n", error);
  582. } else if (!wait_for_completion_timeout(completion,
  583. msecs_to_jiffies(300))) {
  584. dev_err(dev, "timeout waiting for device reset\n");
  585. error = -ETIMEDOUT;
  586. }
  587. disable_irq(client->irq);
  588. if (error)
  589. return error;
  590. len = i2c_master_recv(client, buffer, ETP_I2C_INF_LENGTH);
  591. if (len != ETP_I2C_INF_LENGTH) {
  592. error = len < 0 ? len : -EIO;
  593. dev_err(dev, "failed to read INT signal: %d (%d)\n",
  594. error, len);
  595. return error;
  596. }
  597. return 0;
  598. }
  599. static int elan_i2c_get_report_features(struct i2c_client *client, u8 pattern,
  600. unsigned int *features,
  601. unsigned int *report_len)
  602. {
  603. *features = ETP_FEATURE_REPORT_MK;
  604. *report_len = pattern <= 0x01 ?
  605. ETP_I2C_REPORT_LEN : ETP_I2C_REPORT_LEN_ID2;
  606. return 0;
  607. }
  608. static int elan_i2c_get_report(struct i2c_client *client,
  609. u8 *report, unsigned int report_len)
  610. {
  611. int len;
  612. len = i2c_master_recv(client, report, report_len);
  613. if (len < 0) {
  614. dev_err(&client->dev, "failed to read report data: %d\n", len);
  615. return len;
  616. }
  617. if (len != report_len) {
  618. dev_err(&client->dev,
  619. "wrong report length (%d vs %d expected)\n",
  620. len, report_len);
  621. return -EIO;
  622. }
  623. return 0;
  624. }
  625. const struct elan_transport_ops elan_i2c_ops = {
  626. .initialize = elan_i2c_initialize,
  627. .sleep_control = elan_i2c_sleep_control,
  628. .power_control = elan_i2c_power_control,
  629. .set_mode = elan_i2c_set_mode,
  630. .calibrate = elan_i2c_calibrate,
  631. .calibrate_result = elan_i2c_calibrate_result,
  632. .get_baseline_data = elan_i2c_get_baseline_data,
  633. .get_version = elan_i2c_get_version,
  634. .get_sm_version = elan_i2c_get_sm_version,
  635. .get_product_id = elan_i2c_get_product_id,
  636. .get_checksum = elan_i2c_get_checksum,
  637. .get_pressure_adjustment = elan_i2c_get_pressure_adjustment,
  638. .get_max = elan_i2c_get_max,
  639. .get_resolution = elan_i2c_get_resolution,
  640. .get_num_traces = elan_i2c_get_num_traces,
  641. .iap_get_mode = elan_i2c_iap_get_mode,
  642. .iap_reset = elan_i2c_iap_reset,
  643. .prepare_fw_update = elan_i2c_prepare_fw_update,
  644. .write_fw_block = elan_i2c_write_fw_block,
  645. .finish_fw_update = elan_i2c_finish_fw_update,
  646. .get_pattern = elan_i2c_get_pattern,
  647. .get_report_features = elan_i2c_get_report_features,
  648. .get_report = elan_i2c_get_report,
  649. };